garcun 0.0.2

data/lib/garcon/core_ext/time.rb

@@ -0,0 +1,234 @@
+# 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.
+#
+
+# Add #elapse
+class Time
+  # Tracks the elapse time of a code block.
+  #
+  # @example
+  #   e = Time.elapse { sleep 1 }
+  #   e.assert > 1
+  #
+  def self.elapse
+    raise "you need to pass a block" unless block_given?
+    t0 = now.to_f
+    yield
+    now.to_f - t0
+  end
+
+	# Return a float of time since linux epoch
+	#
+  # @example
+	#   Time.time     -> 1295953427.0005338
+	#
+	# @return [Float]
+  def self.time
+    now.to_f
+  end
+
+  unless const_defined?('FORMAT')
+    FORMAT = {
+      utc:      '%Y-%m-%d %H:%M:%S',        # => 2015-04-19 14:03:59
+      utcT:     '%Y-%m-%dT%H:%M:%S',        # => 2015-04-19T14:03:59
+      db:       '%Y-%m-%d %H:%M:%S',        # => 2015-04-19 14:03:59
+      database: '%Y-%m-%d %H:%M:%S',        # => 2015-04-19 14:03:59
+      number:   '%Y%m%d%H%M%S',             # => 20150419140359
+      short:    '%d %b %H:%M',              # => 19 Apr 14:
+      time:     '%H:%M',                    # => 14:03
+      long:     '%B %d, %Y %H:%M',          # => April 19, 2015 14:03
+      day1st:   '%d-%m-%Y %H:%M',           # => 19-04-2015 14:03
+      dmYHM:    '%d-%m-%Y %H:%M',           # => 19-04-2015 14:03
+      rfc822:   '%a, %d %b %Y %H:%M:%S %z', # => Sun, 19 Apr 2015 14:03:59 -0700
+      ruby18:   '%a %b %d %H:%M:%S %z %Y',  # => Sun Apr 19 14:03:59 -0700 2015
+      nil    => '%Y-%m-%d %H:%M:%S %z'      # => 2015-04-19 14:03:59 -0700
+    }
+  end
+
+  # Produce time stamp for Time.now. See #stamp.
+  #
+  def self.stamp(*args)
+    now.stamp(*args)
+  end
+
+  # Create a time stamp.
+  #
+  # @example
+  #   t = Time.at(10000)
+  #   t.stamp(:short)    # => "31 Dec 21:46"
+  #
+  # Supported formats come from the Time::FORMAT constant.
+  #
+  def stamp(format = nil)
+    unless String === format
+      format = FORMAT[format]
+    end
+    strftime(format).strip
+  end
+
+  unless method_defined?(:dst_adjustment)
+    # Adjust DST
+    #
+    def dst_adjustment(time)
+      self_dst = self.dst? ? 1 : 0
+      time_dst = time.dst? ? 1 : 0
+      seconds  = (self - time).abs
+      if (seconds >= 86400 && self_dst != time_dst)
+        time + ((self_dst - time_dst) * 60 * 60)
+      else
+        time
+      end
+    end
+  end
+
+  # Like change but does not reset earlier times.
+  #
+  def set(options)
+    opts={}
+    options.each_pair do |k,v|
+      k = :min if k.to_s =~ /^min/
+      k = :sec if k.to_s =~ /^sec/
+      opts[k] = v.to_i
+    end
+    self.class.send(
+      self.utc? ? :utc : :local,
+      opts[:year]  || self.year,
+      opts[:month] || self.month,
+      opts[:day]   || self.day,
+      opts[:hour]  || self.hour,
+      opts[:min]   || self.min,
+      opts[:sec]   || self.sec,
+      opts[:usec]  || self.usec
+    )
+  end
+
+  # Returns a new Time representing the time shifted by the time-units given.
+  # Positive number shift the time forward, negative number shift the time
+  # backward.
+  #
+  # @example
+  #   t = Time.utc(2010,10,10,0,0,0)
+  #   t.shift( 4, :days)            # =>  Time.utc(2010,10,14,0,0,0)
+  #   t.shift(-4, :days)            # =>  Time.utc(2010,10,6,0,0,0)
+  #
+  # More than one unit of time can be given.
+  #   t.shift(4, :days, 3, :hours)  # =>  Time.utc(2010,10,14,3,0,0)
+  #
+  # The #shift method can also take a hash.
+  #   t.shift(:days=>4, :hours=>3)  # =>  Time.utc(2010,10,14,3,0,0)
+  #
+  def shift(*time_units)
+    time_hash = Hash===time_units.last ? time_units.pop : {}
+    time_units = time_units.flatten
+    time_units << :seconds if time_units.size % 2 == 1
+    time_hash.each{ |units, number| time_units << number; time_units << units }
+
+    time = self
+    time_units.each_slice(2) do |number, units|
+      #next time = time.ago(-number, units) if number < 0
+      time = (
+        case units.to_s.downcase.to_sym
+        when :years, :year
+          time.set( :year=>(year + number) )
+        when :months, :month
+          if number > 0
+            new_month = ((month + number - 1) % 12) + 1
+            y = (number / 12) + (new_month < month ? 1 : 0)
+            time.set(:year => (year + y), :month => new_month)
+          else
+            number = -number
+            new_month = ((month - number - 1) % 12) + 1
+            y = (number / 12) + (new_month > month ? 1 : 0)
+            time.set(:year => (year - y), :month => new_month)
+          end
+        when :weeks, :week
+          time + (number * 604800)
+        when :days, :day
+          time + (number * 86400)
+        when :hours, :hour
+          time + (number * 3600)
+        when :minutes, :minute, :mins, :min
+          time + (number * 60)
+        when :seconds, :second, :secs, :sec, nil
+          time + number
+        else
+          raise ArgumentError, "unrecognized time units -- #{units}"
+        end
+      )
+    end
+    dst_adjustment(time)
+  end
+
+  # Alias for #shift.
+  alias_method :in, :shift
+
+  # Alias for #shift.
+  alias_method :hence, :shift unless method_defined?(:hence)
+
+  # Returns a new Time representing the time a number of time-units ago.
+  # This is just like #shift, but reverses the direction.
+  #
+  # @example
+  #   t = Time.utc(2010,10,10,0,0,0)
+  #   t.less(4, :days)             # =>  Time.utc(2010,10,6,0,0,0)
+  #
+  def less(*time_units)
+    time_hash  = Hash===time_units.last ? time_units.pop : {}
+    time_units = time_units.flatten
+
+    time_units << :seconds if time_units.size % 2 == 1
+
+    time_hash.each{ |units, number| time_units << number; time_units << units }
+
+    neg_times = []
+    time_units.each_slice(2){ |number, units| neg_times << -number; neg_times << units }
+
+    shift(*neg_times)
+  end
+
+  # Alias for #less
+  alias_method :ago, :less unless method_defined?(:ago)
+end
+
+class Numeric
+  # Reports the approximate distance in time between two Time, Date or DateTime
+  # objects or integers as seconds.
+  #
+  # @example
+  #   1.time_humanize(true)    -> 1 seconds
+  #   36561906.time_humanize   -> 1 years 2 months 3 days 4 hours 5 minutes
+  #
+  def time_humanize(include_seconds = false)
+    deta = self
+    deta,  seconds = deta.divmod(60)
+    deta,  minutes = deta.divmod(60)
+    deta,  hours   = deta.divmod(24)
+    deta,  days    = deta.divmod(30)
+    years, months  = deta.divmod(12)
+
+    ret  = ''
+    ret << "#{years} years "     unless years   == 0
+    ret << "#{months} months "   unless months  == 0
+    ret << "#{days} days "       unless days    == 0
+    ret << "#{hours} hours "     unless hours   == 0
+    ret << "#{minutes} minutes " unless minutes == 0
+    ret << "#{seconds} seconds"      if include_seconds
+
+    ret.rstrip
+  end
+end

data/lib/garcon/exceptions.rb

@@ -0,0 +1,101 @@
+# 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.
+#
+
+# Include hooks to extend Resource with class and instance methods.
+#
+module Garcon
+  # When foo and bar collide, exceptions happen.
+  #
+  module Exceptions
+
+    class UnsupportedPlatform < RuntimeError
+      def initialize(platform)
+        super "This functionality is not supported on platform #{platform}."
+      end
+    end
+
+    class ValidationError < RuntimeError
+      attr_accessor :value, :type
+
+      def initialize(value, type = nil)
+        @value, @type = value, type
+        super(build_message)
+        super(detail)
+      end
+
+      def build_message
+        if type?
+          "#{value} is not a valid #{type}"
+        else
+          "Failed to validate #{value.inspect}"
+        end
+      end
+
+      def type?
+        type.nil? ? false : true
+      end
+
+      # Pretty string output of exception/error object useful for helpful
+      # debug messages.
+      #
+      def detail
+        if backtrace
+          %{#{self.class.name}: #{message}\n  #{backtrace.join("\n  ")}\n  LOGGED FROM: #{caller[0]}}
+        else
+          %{#{self.class.name}: #{message}\n  LOGGED FROM: #{caller[0]}}
+        end
+      end
+    end
+
+    # Raised when errors occur during configuration.
+    ConfigurationError             = Class.new(StandardError)
+
+    # Raised when an object's methods are called when it has not been
+    # properly initialized.
+    InitializationError            = Class.new(StandardError)
+
+    # If the maximum number of ReadWriteLock readers or writers is exceeded.
+    ResourceLimitError             = Class.new(StandardError)
+
+    # Raised by an `Executor` when it is unable to process a given task,
+    # possibly because of a reject policy or other internal error.
+    RejectedExecutionError         = Class.new(StandardError)
+
+    # Raised when an operation times out.
+    TimeoutError                   = Class.new(StandardError)
+    PollingError                   = Class.new(StandardError)
+
+    # Raised when node[:garcon][:databag_type] is not valid.
+    InvalidDataBagTypeError        = Class.new(RuntimeError)
+
+    # Raised when cipher direction is invalid.
+    InvalidCipherError             = Class.new(RuntimeError)
+
+    # Raised when no encryption key password is specified.
+    MissingEncryptionPasswordError = Class.new(RuntimeError)
+
+    ResourceNotFoundError          = Class.new(RuntimeError)
+    InvalidStateError              = Class.new(RuntimeError)
+    InvalidTransitionError         = Class.new(RuntimeError)
+    InvalidCallbackError           = Class.new(RuntimeError)
+    TransitionFailedError          = Class.new(RuntimeError)
+    TransitionConflictError        = Class.new(RuntimeError)
+    GuardFailedError               = Class.new(RuntimeError)
+  end
+end

data/lib/garcon/inflections.rb

@@ -0,0 +1,237 @@
+# 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.
+#
+
+require 'set'
+
+module Garcon
+  # The Inflections transforms words from singular to plural, class names to
+  # table names, modularized class names to ones without, and class names to
+  # foreign keys. The default inflections for pluralization, singularization,
+  # and uncountable words are kept in inflections.rb.
+  #
+  module Inflections
+    # Convert input to UpperCamelCase. Will also convert '/' to '::' which is
+    # useful for converting paths to namespaces.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.camelize(input)
+      input.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:\A|_)(.)/) {$1.upcase}
+    end
+
+    # Convert input to underscored, lowercase string. Changes '::' to '/' to
+    # convert namespaces to paths.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.underscore(input)
+      word = input.gsub(/::/, '/')
+      underscorize(word)
+    end
+
+    # Convert input underscores to dashes.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.dasherize(input)
+      input.tr('_', '-')
+    end
+
+    # Return unscoped constant name.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.demodulize(input)
+      input.split('::').last
+    end
+
+    # Creates a foreign key name
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.foreign_key(input)
+      "#{underscorize(demodulize(input))}_id"
+    end
+
+    # Find a constant with the name specified in the argument string. The name
+    # is assumed to be the one of a top-level constant, constant scope of
+    # caller is igored.
+    #
+    # @param [String] input
+    #
+    # @return [Class, Module]
+    #
+    def self.constantize(input)
+      names = input.split('::')
+      names.shift if names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant.const_defined?(name)
+          constant.const_get(name)
+        else
+          constant.const_missing(name)
+        end
+      end
+    end
+
+    ORDINALIZE_TH = (4..16).to_set.freeze
+
+    # Convert a number into an ordinal string.
+    #
+    # @param [Fixnum] number
+    #
+    # @return [String]
+    #
+    def self.ordinalize(number)
+      abs_value = number.abs
+
+      if ORDINALIZE_TH.include?(abs_value % 100)
+        "#{number}th"
+      else
+        case abs_value % 10
+          when 1; "#{number}st"
+          when 2; "#{number}nd"
+          when 3; "#{number}rd"
+        end
+      end
+    end
+
+    # Convert input word string to plural
+    #
+    # @param [String] word
+    #
+    # @return [String]
+    #
+    def self.pluralize(word)
+      return word if uncountable?(word)
+      inflections.plurals.apply_to(word)
+    end
+
+    # Convert word to singular
+    #
+    # @param [String] word
+    #
+    # @return [String]
+    #
+    def self.singularize(word)
+      return word if uncountable?(word)
+      inflections.singulars.apply_to(word)
+    end
+
+    # Humanize string.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.humanize(input)
+      result = inflections.humans.apply_to(input)
+      result.gsub!(/_id\z/, "")
+      result.tr!('_', " ")
+      result.capitalize!
+      result
+    end
+
+    # Tabelize input string.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.tableize(input)
+      pluralize(underscore(input).gsub('/', '_'))
+    end
+
+    # Create a class name from a plural table name like Rails does for table
+    # names to models.
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.classify(table_name)
+      camelize(singularize(table_name.sub(/.*\./, '')))
+    end
+
+    # Create a snake case string with an optional namespace prepended.
+    #
+    # @param [String] input
+    #
+    # @param [String] namespace
+    #
+    # @return [String]
+    #
+    def self.snakeify(input, namespace = nil)
+      input = input.dup
+      input.sub!(/^#{namespace}(\:\:)?/, '') if namespace
+      input.gsub!(/[A-Z]/) {|s| "_" + s}
+      input.downcase!
+      input.sub!(/^\_/, "")
+      input
+    end
+
+    # Test if word is uncountable.
+    #
+    # @param [String] word
+    #
+    # @return [Boolean] true, if word is uncountable
+    #
+    def self.uncountable?(word)
+      word.empty? || inflections.uncountables.include?(word.downcase)
+    end
+
+    # Convert input to underscored, lowercase string
+    #
+    # @param [String] input
+    #
+    # @return [String]
+    #
+    def self.underscorize(word)
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!('-', '_')
+      word.downcase!
+      word
+    end
+    private_class_method :underscorize
+
+    # Yields a singleton instance of Garcon::Inflections.
+    #
+    # @return [Garcon::Inflections]
+    #
+    def self.inflections
+      instance = Inflections.instance
+      block_given? ? yield(instance) : instance
+    end
+  end
+end
+
+require_relative 'inflections/rules_collection'
+require_relative 'inflections/inflections'
+require_relative 'inflections/defaults'