hoodie 0.1.2

data/lib/hoodie/stash.rb

@@ -0,0 +1,118 @@
+# 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/disk_store' unless defined?(DiskStash)
+require 'hoodie/stash/mem_store' unless defined?(MemStash)
+
+# Define the basic cache and default store objects
+module Stash
+
+  # check if we're using a version if Ruby that supports caller_locations
+  NEW_CALL = Kernel.respond_to? 'caller_locations'
+
+  class << self
+    # insert a helper .new() method for creating a new object
+    #
+    def new(*args)
+      self::Cache.new(*args)
+    end
+
+    # helper to get the calling function name
+    #
+    def caller_name
+      NEW_CALL ? caller_locations(2, 1).first.label : caller[1][/`([^']*)'/, 1]
+    end
+  end
+
+  # Default store type
+  DEFAULT_STORE = MemStash::Cache
+
+  # Key/value cache store
+  class Cache
+    # @return [Hash] of the mem stash cache hash store
+    #
+    attr_reader :store
+
+    # Initializes a new empty store
+    #
+    def initialize(params = {})
+      params = { store: params } unless params.is_a? Hash
+      @store = params.fetch(:store) { Stash::DEFAULT_STORE.new }
+    end
+
+    # Clear the whole stash store or the value of a key
+    #
+    # @param key [Symbol, String] (optional) representing the key to
+    # clear.
+    #
+    # @return nothing.
+    #
+    def clear!(key = nil)
+      key = key.to_sym unless key.nil?
+      @store.clear! key
+    end
+
+    # Retrieves the value for a given key, if nothing is set,
+    # returns KeyError
+    #
+    # @param key [Symbol, String] representing the key
+    #
+    # @raise [KeyError] if no such key found
+    #
+    # @return [Hash, Array, String] value for key
+    #
+    def [](key = nil)
+      key ||= Stash.caller_name
+      fail KeyError, 'Key not cached' unless include? key.to_sym
+      @store[key.to_sym]
+    end
+
+    # Retrieves the value for a given key, if nothing is set,
+    # run the code, cache the result, and return it
+    #
+    # @param key [Symbol, String] representing the key
+    # @param block [&block] that returns the value to set (optional)
+    #
+    # @return [Hash, Array, String] value for key
+    #
+    def cache(key = nil, &code)
+      key ||= Stash.caller_name
+      @store[key.to_sym] ||= code.call
+    end
+
+    # return the size of the store as an integer
+    #
+    # @return [Fixnum]
+    #
+    def size
+      @store.size
+    end
+
+    # return a boolean indicating presence of the given key in the store
+    #
+    # @param key [Symbol, String] a string or symbol representing the key
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    def include?(key = nil)
+      key ||= Stash.caller_name
+      @store.include? key.to_sym
+    end
+  end
+end

data/lib/hoodie/stash/disk_store.rb

@@ -0,0 +1,151 @@
+# 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 'tmpdir'
+
+module DiskStash
+	# Disk stashing method variable caching hash, string, array store.
+	class Cache
+		include Enumerable
+
+    # @return [String] location of DiskStash::Cache.store
+    #
+    attr_reader :store
+
+    # Initializes a new disked backed stash hash cache store.
+    #
+    # @param path [String] location for stash store cache.
+    #
+    # @return nothing.
+    #
+    def initialize(store = file_store)
+    	@store = store
+      ensure_store_directory
+    end
+
+	  # Clear the whole stash or the value of a key
+	  #
+	  # @param key [Symbol, String] (optional) string or symbol
+    # representing the key to clear
+	  #
+	  # @return [Hash] with a key, return the value it had, without
+    # returns {}
+	  #
+    def clear!(key = nil)
+      if key.nil?
+        ::Dir[::File.join(store, '*.cache')].each do |file|
+          ::File.delete(file)
+        end
+      else
+        ::File.delete(cache_file(key)) if ::File.exists?(cache_file(key))
+      end
+    end
+
+		# Retrieves the value for a given key, if nothing is set,
+    # returns KeyError
+    #
+    # @param key [Symbol, String] representing the key
+    #
+    # @raise [KeyError] if no such key found
+    #
+    # @return [Hash, Array, String] value for key
+    #
+    def [](key)
+      if key.is_a? Array
+        hash = {}
+        key.each do |k|
+          hash[k] = Marshal::load(read_cache_file(k))
+        end
+        hash unless hash.empty?
+      else
+        Marshal::load(read_cache_file(key))
+      end
+    rescue Errno::ENOENT
+      nil # key hasn't been created
+    end
+
+    # Store the given value with the given key, either an an argument
+    # or block. If a previous value was set it will be overwritten
+    # with the new value.
+    #    #
+    # @param key [Symbol, String] representing the key
+    # @param value [Object] that represents the value (optional)
+    # @param block [&block] that returns the value to set (optional)
+    #
+    # @return nothing.
+    #
+    def []=(key, value)
+    	write_cache_file(key, Marshal::dump(value))
+    end
+
+		# returns path to cache file with 'key'
+	  def cache_file key
+	  	::File.join(store, key.to_s + '.cache')
+	  end
+
+		private #   P R O P R I E T À   P R I V A T A   divieto di accesso
+
+    # return Chef tmpfile path if running under Chef, else return OS
+    # temp path. On Winders Dir.tmpdir returns the correct path.
+    #
+    def file_store
+      tmp = defined?(Chef::Config) ? Chef::Config[:file_cache_path] : Dir.tmpdir
+      if OS.windows?
+        win_friendly_path(::File.join(tmp, '._stash'))
+      else
+        '_stash'
+        # ::File.join(tmp, '._stash')
+      end
+    end
+
+    # returns windows friendly version of the provided path, ensures
+    # backslashes are used everywhere
+    #
+    def win_friendly_path(path)
+      system_drive = ENV['SYSTEMDRIVE'] ? ENV['SYSTEMDRIVE'] : ""
+      path = ::File.join(system_drive, path)
+      path.gsub!(::File::SEPARATOR, (::File::ALT_SEPARATOR || '\\'))
+    end
+
+    def write_cache_file(key, content)
+      f = ::File.open(cache_file(key), 'w+' )
+      f.flock(::File::LOCK_EX)
+      f.write(content)
+      f.close
+      content
+    end
+
+    def read_cache_file(key)
+    	f = ::File.open(cache_file(key), 'r')
+    	f.flock(::File::LOCK_SH)
+    	out = f.read
+    	f.close
+    	out
+    end
+
+	  def read_cache_mtime(key)
+	  	nil unless ::File.exists?(cache_file(key))
+	  	::File.mtime(cache_file(key))
+	  end
+
+	  def ensure_store_directory
+	  	::Dir.mkdir(store) unless ::File.directory?(store)
+	  end
+	end
+end

data/lib/hoodie/stash/mem_store.rb

@@ -0,0 +1,150 @@
+# 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 MemStash
+  # Basic cache object stash store (uses a Hash)
+  class Cache
+    include Enumerable
+
+    # @return [Hash] of the mem stash cache hash store
+    #
+    attr_reader :store
+
+    # Initializes a new store object.
+    #
+    # @param data [Hash] (optional) data to load into the stash.
+    #
+    # @return nothing.
+    #
+    def initialize(_ = {})
+      @store = {}
+    end
+
+    # Clear the whole stash store or the value of a key
+    #
+    # @param key [Symbol, String] (optional) representing the key to
+    # clear.
+    #
+    # @return nothing.
+    #
+    def clear!(key = nil)
+      key.nil? ? @store.clear : @store.delete(key)
+    end
+
+    # Retrieves the value for a given key, if nothing is set,
+    # returns KeyError
+    #
+    # @param key [Symbol, String] representing the key
+    #
+    # @raise [KeyError] if no such key found
+    #
+    # @return [Hash, Array, String] value for key
+    #
+    def [](key)
+      @store[key]
+    end
+
+    # Store the given value with the given key, either an an argument
+    # or block. If a previous value was set it will be overwritten
+    # with the new value.
+    #
+    # @example store a value
+    #
+    #   stash.set('name') { 'Trigster' }
+    #      => "Trigster"
+    #   stash[:cash] = 'in the hash stash cache store'
+    #      => "in the hash stash cache store"
+    #   data = { id: 'trig', name: 'Trigster Jay', passwd: 'f00d' }
+    #   stash[:juser] = data
+    #      => {
+    #            :id => "trig",
+    #          :name => "Trigster Jay",
+    #        :passwd => "f00d"
+    #      }
+    #
+    # @param key [Symbol, String] string or symbol representing the key
+    # @param value [Object] any object that represents the value (optional)
+    # @param block [&block] that returns the value to set (optional)
+    #
+    # @return nothing.
+    #
+    def []=(key, value)
+      @store[key] = value
+    end
+
+    # Iterates over all key-value pairs.
+    #
+    # @param block [&block] that will receive the key/value of each pair
+    #
+    # @yield the string key and value.
+    #
+    def each(&block)
+      @store.each { |k, v| yield(k, v) }
+    end
+
+    # Loads a hash of data into the stash.
+    #
+    # @param hash [Hash] of data with either String or Symbol keys.
+    #
+    # @return nothing.
+    #
+    def load(data)
+      data.each do |key, value|
+        @store[key] = value
+      end
+    end
+
+    # return the size of the store as an integer
+    #
+    # @return [Fixnum]
+    #
+    def size
+      @store.size
+    end
+
+    # return a boolean indicating presence of the given key in the store
+    #
+    # @param key [Symbol, String] a string or symbol representing the key
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    def include?(key)
+      @store.include? key
+    end
+    alias_method :key?, :include?
+
+    # return a boolean indicating presence of the given value in the store
+    #
+    # @param value [String] a string representing the value
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    def value?(value)
+      @store.value? value
+    end
+
+    # return all keys in the store as an array
+    #
+    # @return [Array<String, Symbol>] all the keys in store
+    #
+    def keys
+      @store.keys
+    end
+  end
+end

data/lib/hoodie/utils.rb

@@ -0,0 +1,134 @@
+# 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
+  # Returns an aligned_string of text relative to the size of the terminal
+  # window. If a line in the string exceeds the width of the terminal window
+  # the line will be chopped off at the whitespace chacter closest to the
+  # end of the line and prepended to the next line, keeping all indentation.
+  #
+  # The terminal size is detected by default, but custom line widths can
+  # passed. All strings will also be left aligned with 5 whitespace characters
+  # by default.
+  def self.align_text(text, console_cols = nil, preamble = 5)
+    unless console_cols
+      console_cols = terminal_dimensions[0]
+
+      # if unknown size we default to the typical unix default
+      console_cols = 80 if console_cols == 0
+    end
+
+    console_cols -= preamble
+
+    # Return unaligned text if console window is too small
+    return text if console_cols <= 0
+
+    # If console is 0 this implies unknown so we assume the common
+    # minimal unix configuration of 80 characters
+    console_cols = 80 if console_cols <= 0
+
+    text = text.split("\n")
+    piece = ''
+    whitespace = 0
+
+    text.each_with_index do |line, i|
+      whitespace = 0
+
+      while whitespace < line.length && line[whitespace].chr == ' '
+        whitespace += 1
+      end
+
+      # If the current line is empty, indent it so that a snippet
+      # from the previous line is aligned correctly.
+      if line == ""
+        line = (" " * whitespace)
+      end
+
+      # If text was snipped from the previous line, prepend it to the
+      # current line after any current indentation.
+      if piece != ''
+        # Reset whitespaces to 0 if there are more whitespaces than there are
+        # console columns
+        whitespace = 0 if whitespace >= console_cols
+
+        # If the current line is empty and being prepended to, create a new
+        # empty line in the text so that formatting is preserved.
+        if text[i + 1] && line == (" " * whitespace)
+          text.insert(i + 1, "")
+        end
+
+        # Add the snipped text to the current line
+        line.insert(whitespace, "#{piece} ")
+      end
+
+      piece = ''
+
+      # Compare the line length to the allowed line length.
+      # If it exceeds it, snip the offending text from the line
+      # and store it so that it can be prepended to the next line.
+      if line.length > (console_cols + preamble)
+        reverse = console_cols
+
+        while line[reverse].chr != ' '
+          reverse -= 1
+        end
+
+        piece = line.slice!(reverse, (line.length - 1)).lstrip
+      end
+
+      # If a snippet exists when all the columns in the text have been
+      # updated, create a new line and append the snippet to it, using
+      # the same left alignment as the last line in the text.
+      if piece != '' && text[i+1].nil?
+        text[i+1] = "#{' ' * (whitespace)}#{piece}"
+        piece = ''
+      end
+
+      # Add the preamble to the line and add it to the text
+      line = ((' ' * preamble) + line)
+      text[i] = line
+    end
+
+    text.join("\n")
+  end
+
+  # Figures out the columns and lines of the current tty
+  #
+  # Returns [0, 0] if it can't figure it out or if you're
+  # not running on a tty
+  def self.terminal_dimensions(stdout = STDOUT, environment = ENV)
+    return [0, 0] unless stdout.tty?
+
+    return [80, 40] if Util.windows?
+
+    if environment["COLUMNS"] && environment["LINES"]
+      return [environment["COLUMNS"].to_i, environment["LINES"].to_i]
+
+    elsif environment["TERM"] && command_in_path?("tput")
+      return [`tput cols`.to_i, `tput lines`.to_i]
+
+    elsif command_in_path?('stty')
+      return `stty size`.scan(/\d+/).map {|s| s.to_i }
+    else
+      return [0, 0]
+    end
+  rescue
+    [0, 0]
+  end
+end