hoodie 0.1.2

data/lib/hoodie/hash.rb

@@ -0,0 +1,167 @@
+# encoding: UTF-8
+#
+# Author: Stefano Harding <riddopic@gmail.com>
+#
+# Copyright (C) 2014 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.
+#
+
+class Hash
+  # Returns a compacted copy (contains no key/value pairs having
+  # nil? values)
+  #
+  # @example
+  #     hash = { a: 100, b: nil, c: false, d: '' }
+  #     hash.compact # => { a: 100, c: false, d: '' }
+  #     hash         # => { a: 100, b: nil, c: false, d: '' }
+  #
+  # @return [Hash]
+  #
+  def compact
+    select { |_, value| !value.nil? }
+  end
+
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  # @example
+  #     hash = { name: 'Tiggy', age: '15' }
+  #
+  #     hash.transform_keys{ |key| key.to_s.upcase }
+  #                 # => { "AGE" => "15", "NAME" => "Tiggy" }
+  #
+  # @return [Hash]
+  #
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Returns a new hash, recursively converting all keys by the
+  # block operation.
+  #
+  # @return [Hash]
+  #
+  def recursively_transform_keys(&block)
+    _recursively_transform_keys_in_object(self, &block)
+  end
+
+  # Returns a new hash with all keys downcased and converted
+  # to symbols.
+  #
+  # @return [Hash]
+  #
+  def normalize_keys
+    transform_keys { |key| key.downcase.to_sym rescue key }
+  end
+
+  # Returns a new Hash, recursively downcasing and converting all
+  # keys to symbols.
+  #
+  # @return [Hash]
+  #
+  def recursively_normalize_keys
+    recursively_transform_keys { |key| key.downcase.to_sym rescue key }
+  end
+
+  # Returns a new hash with all keys converted to symbols.
+  #
+  # @return [Hash]
+  #
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Returns a new Hash, recursively converting all keys to symbols.
+  #
+  # @return [Hash]
+  #
+  def recursively_symbolize_keys
+    recursively_transform_keys { |key| key.downcase.to_sym rescue key }
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  # @return [Hash]
+  #
+  def stringify_keys
+    transform_keys { |key| key.to_s rescue key }
+  end
+
+  # Returns a new Hash, recursively converting all keys to strings.
+  #
+  # @return [Hash]
+  #
+  def recursively_stringify_key
+    recursively_transform_keys { |key| key.to_s rescue key }
+  end
+
+  class UndefinedPathError < StandardError; end
+  # Recursively searchs a nested datastructure for a key and returns
+  # the value. If a block is provided its value will be returned if
+  # the key does not exist
+  #
+  # @example
+  #     options = { server: { location: { row: { rack: 34 } } } }
+  #     options.recursive_fetch :server, :location, :row, :rack
+  #                 # => 34
+  #     options.recursive_fetch(:non_existent_key) { 'default' }
+  #                 # => "default"
+  #
+  # @return [Hash, Array, String] value for key
+  #
+  def recursive_fetch(*args, &block)
+    args.reduce(self) do |obj, arg|
+      begin
+        arg = Integer(arg) if obj.is_a? Array
+        obj.fetch(arg)
+      rescue ArgumentError, IndexError, NoMethodError => e
+        break block.call(arg) if block
+        raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
+      end
+    end
+  end
+
+  def recursive_merge(other)
+    hash = self.dup
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        hash[key] = myval.recursive_merge(value)
+      else
+        hash[key] = value
+      end
+    end
+    hash
+  end
+
+  private #   P R O P R I E T À   P R I V A T A   divieto di accesso
+
+  # support methods for recursively transforming nested hashes and arrays
+  def _recursively_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _recursively_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _recursively_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/hoodie/memoizable.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+#
+# Author: Stefano Harding <riddopic@gmail.com>
+#
+# Copyright (C) 2014 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
+      (class << self; self; end).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

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+#
+# Author: Stefano Harding <riddopic@gmail.com>
+#
+# Copyright (C) 2014 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
+      raise 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 passphrase 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
+
+    private #   P R O P R I E T À   P R I V A T A   divieto di accesso
+
+    # Cipher create machine do, befuddle engage, enlighten. Dials set
+    # direction to infinity
+    #
+    # @param [:befuddle, :enlighten] to befuddle or enlighten
+    # @param [String] befuddle_pass secret passphrase to enlighten
+    #
+    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 raise "Bad cipher direction #{direction}"
+      end
+      cipher.key = befuddle_key(befuddle_pass, options)
+      cipher
+    end
+
+    # prepend the initialization vector to the encoded 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
+
+    # pull the initialization vector from the front of the encoded 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
+      raise 'Missing befuddled password!' if befuddle_pass.empty?
+      # this provides the required 256 bits of key for the aes-256-cbc
+      # cipher
+      Digest::SHA256.digest(befuddle_pass)
+    end
+  end
+end

data/lib/hoodie/os.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+#
+# Author: Stefano Harding <riddopic@gmail.com>
+#
+# Copyright (C) 2014 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 'rbconfig' unless defined?(RbConfig)
+
+# Finds out the current Operating System.
+module OS
+  def self.windows?
+    windows = /cygwin|mswin|mingw|bccwin|wince|emx/i
+    (RbConfig::CONFIG['host_os'] =~ windows) != nil
+  end
+
+  def self.mac?
+    mac = /darwin|mac os/i
+    (RbConfig::CONFIG['host_os'] =~ mac) != nil
+  end
+
+  def self.unix?
+    unix = /solaris|bsd/i
+    (RbConfig::CONFIG['host_os'] =~ unix) != nil
+  end
+
+  def self.linux?
+    linux = /linux/i
+    (RbConfig::CONFIG['host_os'] =~ linux) != nil
+  end
+end

data/lib/hoodie/path_finder.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+#
+# Author: Stefano Harding <riddopic@gmail.com>
+#
+# Copyright (C) 2014 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.
+#
+
+# TODO: This doesn't belong in here, it's cookbook specific...
+require 'anemone' unless defined?(Anemone)
+require 'hoodie/memoizable' unless defined?(Memoizable)
+
+class PathFinder
+  include Memoizable
+
+  def initialize(url)
+    @url = url
+    memoize [:fetch], Stash.new(DiskStash::Cache.new)
+  end
+
+  def fetch(path)
+    results = []
+    Anemone.crawl(@url, discard_page_bodies: true) do |anemone|
+      anemone.on_pages_like(/\/#{path}\/\w+\/\w+\.(ini|zip)$/i) do |page|
+        results << page.to_hash
+      end
+    end
+    results.reduce({}, :recursive_merge)
+  end
+end
+
+# to_hash smoke cache
+#
+module Anemone
+  class Page
+    def to_hash
+      file  = ::File.basename(@url.to_s)
+      key   = ::File.basename(file, '.*').downcase.to_sym
+      type  = ::File.extname(file)[1..-1].downcase.to_sym
+      id    = Hoodie::Obfuscate.befuddle(file, Digest::MD5.hexdigest(body.to_s))
+      mtime = Time.parse(@headers['last-modified'][0]).to_i
+      utime = Time::now.to_i
+      state = utime > mtime ? :clean : :dirty
+      key = { key => { type => {
+        id:             id,
+        cache_state:    state,
+        file:           file,
+        key:            key,
+        type:           type,
+        url:            @url.to_s,
+        mtime:          mtime,
+        links:          links.map(&:to_s),
+        code:           @code,
+        visited:        @visited,
+        depth:          @depth,
+        referer:        @referer.to_s,
+        fetched:        @fetched,
+        utime:          utime,
+        md5_digest:     Digest::MD5.hexdigest(body.to_s),
+        sha256_digest:  Digest::SHA256.hexdigest(body.to_s)
+      }}}
+    end
+  end
+end