garcun 0.0.2

data/lib/garcon/inflections/defaults.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# 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.
+#
+
+Garcon::Inflections.inflections do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/^(ax|test)is$/i, '\1es')
+  inflect.plural(/(octop|vir)us$/i, '\1i')
+  inflect.plural(/(octop|vir)i$/i, '\1i')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  inflect.plural(/([ti])um$/i, '\1a')
+  inflect.plural(/([ti])a$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+  inflect.plural(/^(m|l)ouse$/i, '\1ice')
+  inflect.plural(/^(m|l)ice$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/^(oxen)$/i, '\1')
+  inflect.plural(/(quiz)$/i, '\1zes')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(ss)$/i, '\1')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([ti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+  inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/([lr])ves$/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.singular(/(s)eries$/i, '\1eries')
+  inflect.singular(/(m)ovies$/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  inflect.singular(/^(m|l)ice$/i, '\1ouse')
+  inflect.singular(/(bus)(es)?$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+  inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+  inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+  inflect.singular(/(alias|status)(es)?$/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+  inflect.singular(/(database)s$/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  inflect.irregular('zombie', 'zombies')
+
+  inflect.uncountable(%w(hovercraft moose milk rain Swiss grass equipment information rice money species series fish sheep jeans))
+end

data/lib/garcon/inflections/inflections.rb

@@ -0,0 +1,182 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# 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 Garcon
+  module Inflections
+    # A singleton instance of this class is yielded by Garcon.inflections,
+    # which can then be used to specify additional inflection rules. Examples:
+    #
+    #   Inflections.inflections do |inflect|
+    #     inflect.plural /^(ox)$/i, '\1\2en'
+    #     inflect.singular /^(ox)en/i, '\1'
+    #
+    #     inflect.irregular 'octopus', 'octopi'
+    #
+    #     inflect.uncountable "equipment"
+    #   end
+    #
+    # New rules are added at the top. So in the example above, the irregular
+    # rule for octopus will now be the first of the pluralization and
+    # singularization rules that is runs. This guarantees that your rules run
+    # before any of the rules that may already have been loaded.
+    #
+    class Inflections
+
+      # Return instance
+      #
+      # @return [Inflections]
+      # @api private
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      # @return [Array] plurals
+      # @api private
+      attr_reader :plurals
+
+      # @return [Array] singulars
+      # @api private
+      attr_reader :singulars
+
+      # @return [Array] uncountables
+      # @api private
+      attr_reader :uncountables
+
+      # @return [Array] humans
+      # @api private
+      attr_reader :humans
+
+      # Initialize object
+      #
+      # @return [undefined]
+      # @api private
+      def initialize
+        @plurals      = RulesCollection.new
+        @singulars    = RulesCollection.new
+        @humans       = RulesCollection.new
+        @uncountables = Set[]
+      end
+
+      # Specifies a new pluralization rule and its replacement. The rule can
+      # either be a string or a regular expression. The replacement should
+      # always be a string that may include references to the matched data from
+      # the rule.
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @return [self]
+      # @api private
+      def plural(rule, replacement)
+        rule(rule, replacement, @plurals)
+        self
+      end
+
+      # Specifies a new singularization rule and its replacement. The rule can
+      # either be a string or a regular expression. The replacement should
+      # always be a string that may include references to the matched data from
+      # the rule.
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @return [self]
+      # @api private
+      def singular(rule, replacement)
+        rule(rule, replacement, @singulars)
+        self
+      end
+
+      # Specifies a new irregular that applies to both pluralization and
+      # singularization at the same time. This can only be used for strings, not
+      # regular expressions. You simply pass the irregular in singular and
+      # plural form.
+      #
+      # @param [String] singular
+      # @param [String] plural
+      # @return [self]
+      # @api private
+      def irregular(singular, plural)
+        @uncountables.delete(singular)
+        @uncountables.delete(plural)
+        add_irregular(singular, plural, @plurals)
+        add_irregular(plural, singular, @singulars)
+        self
+      end
+
+      # Uncountable will not be inflected
+      #
+      # @param [Enumerable<String>] words
+      # @return [self]
+      # @api private
+      def uncountable(*words)
+        @uncountables.merge(words.flatten)
+        self
+      end
+
+      # Specifies a humanized form of a string by a regular expression rule or
+      # by a string mapping. When using a regular expression based replacement,
+      # the normal humanize formatting is called after the replacement. When a
+      # string is used, the human form should be specified as desired (example:
+      # 'The name', not 'the_name')
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @return [self]
+      # @api private
+      def human(rule, replacement)
+        @humans.insert(0, [rule, replacement])
+        self
+      end
+
+      # Clear all inflection rules
+      #
+      # @return [self]
+      # @api private
+      def clear
+        initialize
+        self
+      end
+
+      private #        P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+      # Add irregular inflection
+      #
+      # @param [String] rule
+      # @param [String] replacement
+      # @return [undefined]
+      # @api private
+      def add_irregular(rule, replacement, target)
+        head, *tail = rule.chars.to_a
+        rule(/(#{head})#{tail.join}\z/i, '\1' + replacement[1..-1], target)
+      end
+
+      # Add a new rule
+      #
+      # @param [String, Regexp] rule
+      # @param [String, Regexp] replacement
+      # @param [Array] target
+      # @return [undefined]
+      # @api private
+      def rule(rule, replacement, target)
+        @uncountables.delete(rule)
+        @uncountables.delete(replacement)
+        target.insert(0, [rule, replacement])
+      end
+    end
+  end
+end

data/lib/garcon/inflections/rules_collection.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# 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 Garcon
+  module Inflections
+    # Wraps inflections array
+    #
+    class RulesCollection < Array
+      # Applies first found rule to given word
+      #
+      # @param [String] word
+      # @return [String] modified word
+      # @api private
+      def apply_to(word)
+        result = word.dup
+        each { |rule, replacement| break if result.gsub!(rule, replacement) }
+        result
+      end
+    end
+  end
+end

data/lib/garcon/secret.rb

@@ -0,0 +1,271 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# 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.
+#
+
+#     ______  __ __    ___       _____   ___     __  ____     ___  ______
+#    |      T|  T  T  /  _]     / ___/  /  _]   /  ]|    \   /  _]|      T
+#    |      ||  l  | /  [_     (   \_  /  [_   /  / |  D  ) /  [_ |      |
+#    l_j  l_j|  _  |Y    _]     \__  TY    _] /  /  |    / Y    _]l_j  l_j
+#      |  |  |  |  ||   [_      /  \ ||   [_ /   \_ |    \ |   [_   |  |
+#      |  |  |  |  ||     T     \    ||     T\     ||  .  Y|     T  |  |
+#      l__j  l__j__jl_____j      \___jl_____j \____jl__j\_jl_____j  l__j
+#
+#     __  _    ___    ___  ____    ___  ____   __
+#    |  l/ ]  /  _]  /  _]|    \  /  _]|    \ |  T
+#    |  ' /  /  [_  /  [_ |  o  )/  [_ |  D  )|  |
+#    |    \ Y    _]Y    _]|   _/Y    _]|    / |__j
+#    |     Y|   [_ |   [_ |  |  |   [_ |    \  __
+#    |  .  ||     T|     T|  |  |     T|  .  Y|  T
+#    l__j\_jl_____jl_____jl__j  l_____jl__j\_jl__j
+
+require 'tempfile'
+require 'fileutils'
+require_relative 'utility/crypto'
+require_relative 'utility/memstash'
+
+module Garcon
+  # Creates a transient file with sensitive content, usefule when you have an
+  # excecutable that reads a password from a file but you do not wish to leave
+  # the password on the filesystem. When used in a block parameter the file is
+  # written and deleted when the block returns, optionally you can encrypt and
+  # decrypt your secret strings with salt, cipher and a splash of obfuscation.
+  #
+  module Secret
+    # A Configuration instance
+    class Configuration
+
+      # @!attribute [r] :lock
+      #   @return [String] Access the shared Monitor for this instance.
+      attr_reader :lock
+
+      # @!attribute [rw] :stash
+      #   @return [String] The shared Stash (in-memory cache) for this instance.
+      attr_accessor :stash
+
+      # @!attribute [rw] :queue
+      #   @return [String] The shared queue object for this instance.
+      attr_accessor :queue
+
+      # Initialized a configuration instance
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(options = {})
+        @lock   = Monitor.new
+        @stash  = MemStash.new
+        @queue  = MutexPriorityQueue.new
+        @queue << Secret.tmpfile until @queue.length >= 4
+
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_h
+        { lock:  lock,
+          stash: stash,
+          queue: queue
+        }.freeze
+      end
+    end
+
+    # Encrypt and store the given value with the given key, either with an an
+    # argument or block. If a previous value was set it will be overwritten
+    # with the new value.
+    #
+    # @param key [Symbol, String]
+    #   String or symbol representing the key.
+    #
+    # @param value [Object]
+    #   Any object that represents the value.
+    #
+    # @yield [Block]
+    #   Optionally specify a block that returns the value to set.
+    #
+    # @return [String]
+    #   The encrypted value.
+    #
+    def self.set(key, value)
+      Garcon.secret.stash[key] = value.encrypt
+    end
+
+    # Retrieve and decrypt a value at key from the stash.
+    #
+    # @param key [Symbol, String]
+    #   String or symbol representing the key.
+    #
+    # @raise [KeyError]
+    #   If no such key found.
+    #
+    # @return [String]
+    #   Unencrypted value.
+    #
+    def self.get(key)
+      (Garcon.secret.stash[key]).decrypt
+    end
+
+    # Creates the secrets file yields to the block, removes the secrets file
+    # when the block returns
+    #
+    # @example
+    #   secret.tmp { |file| shell_out!("open_sesame --passwd-file #{file}") }
+    #
+    # @yield [Block]
+    #   invokes the block
+    #
+    # @yieldreturn [Object]
+    #   the result of evaluating the optional block
+    #
+    # @api public
+    def self.tmp(key, *args, &block)
+      Garcon.secret.lock.synchronize do
+        begin
+          file = queue.pop
+          atomic_write(file, get(key)) unless valid?(key, file)
+          yield file if block_given?
+        ensure
+          File.unlink(file) if File.exist?(file)
+        end
+      end
+    end
+
+    # Search a text file for a matching string
+    #
+    # @return [Boolean]
+    #   True if the file is present and a match was found, otherwise returns
+    #   false if file does not exist and/or does not contain a match
+    #
+    # @api public
+    def self.valid?(key, file)
+      Garcon.secret.lock.synchronize do
+        return false unless File.exist?(file)
+        File.open(file, &:readlines).map! do |line|
+          return true if line.match(get(key))
+        end
+        false
+      end
+    end
+
+    private #        P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+    def self.queue
+      until Garcon.secret.queue.length >= 2
+        Garcon.secret.queue << Secret.tmpfile
+      end
+      Garcon.secret.queue
+    end
+
+    # Write the secrets file
+    #
+    # @return [String]
+    #   the path to the file
+    #
+    # @api private
+    def self.write(key, file)
+      Garcon.secret.lock.synchronize do
+        begin
+          atomic_write(file, get(key)) unless valid?(key, file)
+        ensure
+          File.chmod(00400, file)
+        end
+      end
+    end
+
+    # Delete the secrets file
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.delete(file = nil)
+      Garcon.secret.lock.synchronize do
+        if file.nil?
+          until Garcon.secret.queue.length == 0
+            tmpfile = Garcon.secret.queue.pop
+            File.unlink(tmpfile) if File.exist?(tmpfile)
+          end
+        else
+          File.unlink(file) if File.exist?(file)
+        end
+      end
+    end
+
+    # Write to a file atomically. Useful for situations where you don't
+    # want other processes or threads to see half-written files.
+    #
+    # @param [String] file
+    #   fill path of the file to write to
+    # @param [String] secret
+    #   content to write to file
+    #
+    # @api private
+    def self.atomic_write(file, secret, tmp_dir = Dir.tmpdir)
+      tmp_file = Tempfile.new(File.basename(file), tmp_dir)
+      tmp_file.write(secret)
+      tmp_file.close
+
+      FileUtils.mv(tmp_file.path, file)
+      begin
+        File.chmod(00400, file)
+      rescue Errno::EPERM, Errno::EACCES
+        # Changing file ownership/permissions failed
+      end
+    ensure
+      tmp_file.close
+      tmp_file.unlink
+    end
+
+    # Lock a file for a block so only one process can modify it at a time
+    #
+    # @param [String] file
+    #   fill path of the file to lock
+    #
+    # @yield [Block]
+    #   invokes the block
+    #
+    # @yieldreturn [Object]
+    #   the result of evaluating the optional block
+    #
+    # @api private
+    def self.lock_file(file, &block)
+      if File.exist?(file)
+        File.open(file, 'r+') do |f|
+          begin
+            f.flock File::LOCK_EX
+            yield
+          ensure
+            f.flock File::LOCK_UN
+          end
+        end
+      else
+        yield
+      end
+    end
+
+    # @return [String] tmp_file
+    # @api private
+    def self.tmpfile(tmp_dir = Dir.tmpdir)
+      Tempfile.new(random_seed, tmp_dir).path.freeze
+    end
+
+    # @return [String] random_seed
+    # @api private
+    def self.random_seed
+      SecureRandom.random_number(0x100000000).to_s(36)
+    end
+  end
+end