garcun 0.0.2

data/lib/garcon/utility/equalizer.rb

@@ -0,0 +1,146 @@
+# 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
+  # Define equality, equivalence and inspection methods.
+  #
+  class Equalizer
+
+    # Initialize an Equalizer with the given keys.
+    #
+    # Will use the keys with which it is initialized to define #cmp?,
+    # #hash, and #inspect
+    #
+    # @param [String] name
+    #
+    # @param [Array<Symbol>] keys
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(name, keys = [])
+      @name = name.dup.freeze
+      @keys = keys.dup
+      define_methods
+      include_comparison_methods
+    end
+
+    # Append a key and compile the equality methods.
+    #
+    # @return [Equalizer] self
+    #
+    # @api private
+    def <<(key)
+      @keys << key
+      self
+    end
+
+    private #        P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+    # Define the equalizer methods based on #keys.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_methods
+      define_cmp_method
+      define_hash_method
+      define_inspect_method
+    end
+
+    # Define an #cmp? method based on the instance's values identified by #keys.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_cmp_method
+      keys = @keys
+      define_method(:cmp?) do |comparator, other|
+        keys.all? { |key| send(key).send(comparator, other.send(key)) }
+      end
+    end
+
+    # Define a #hash method based on the instance's values identified by #keys.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_hash_method
+      keys = @keys
+      define_method(:hash) do
+        keys.map { |key| send(key) }.push(self.class).hash
+      end
+    end
+
+    # Define an inspect method that reports the values of the instance's keys.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_inspect_method
+      name, keys = @name, @keys
+      define_method(:inspect) do
+        "#<#{name}#{keys.map { |key| " #{key}=#{send(key).inspect}" }.join}>"
+      end
+    end
+
+    # Include the #eql? and #== methods
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def include_comparison_methods
+      module_eval { include Methods }
+    end
+
+    # The comparison methods
+    module Methods
+
+      # Compare the object with other object for equality.
+      #
+      # @example
+      #   object.eql?(other)  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) && cmp?(__method__, other)
+      end
+
+      # Compare the object with other object for equivalency.
+      #
+      # @example
+      #   object == other  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        other.kind_of?(self.class) && cmp?(__method__, other)
+      end
+    end
+  end
+end

data/lib/garcon/utility/faker/extensions/array.rb

@@ -0,0 +1,22 @@
+class Array
+  unless self.method_defined? :sample
+    def sample(n = nil)
+      #based on code from https://github.com/marcandre/backports
+      size = self.length
+      return self[Kernel.rand(size)] if n.nil?
+
+      n = n.to_int
+      raise ArgumentError, "negative array size" if n < 0
+
+      n = size if n > size
+
+      result = Array.new(self)
+      n.times do |i|
+        r = i + Kernel.rand(size - i)
+        result[i], result[r] = result[r], result[i]
+      end
+      result[n..size] = []
+      result
+    end
+  end
+end

data/lib/garcon/utility/faker/extensions/symbol.rb

@@ -0,0 +1,9 @@
+# For Ruby 1.8
+unless :symbol.respond_to?(:downcase)
+  Symbol.class_eval do
+    def downcase
+      to_s.downcase.intern
+    end
+  end
+end
+

data/lib/garcon/utility/faker/faker.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+mydir = File.expand_path(File.dirname(__FILE__))
+
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'i18n'
+require 'set' # Fixes a bug in i18n 0.6.11
+
+if I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = true
+end
+I18n.load_path += Dir[File.join(mydir, 'locales', '*.yml')]
+
+
+module Faker
+  class Config
+    @locale = nil
+
+    class << self
+      attr_writer :locale
+      def locale
+        @locale || I18n.locale
+      end
+    end
+  end
+
+  class Base
+    Numbers = Array(0..9)
+    ULetters = Array('A'..'Z')
+    Letters = ULetters + Array('a'..'z')
+
+    class << self
+      ## make sure numerify results doesn’t start with a zero
+      def numerify(number_string)
+        number_string.sub(/#/) { (rand(9)+1).to_s }.gsub(/#/) { rand(10).to_s }
+      end
+
+      def letterify(letter_string)
+        letter_string.gsub(/\?/) { ULetters.sample }
+      end
+
+      def bothify(string)
+        letterify(numerify(string))
+      end
+
+      # Given a regular expression, attempt to generate a string
+      # that would match it.  This is a rather simple implementation,
+      # so don't be shocked if it blows up on you in a spectacular fashion.
+      #
+      # It does not handle ., *, unbounded ranges such as {1,},
+      # extensions such as (?=), character classes, some abbreviations
+      # for character classes, and nested parentheses.
+      #
+      # I told you it was simple. :) It's also probably dog-slow,
+      # so you shouldn't use it.
+      #
+      # It will take a regex like this:
+      #
+      # /^[A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}$/
+      #
+      # and generate a string like this:
+      #
+      # "U3V  3TP"
+      #
+      def regexify(re)
+        re = re.source if re.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
+        re.
+          gsub(/^\/?\^?/, '').gsub(/\$?\/?$/, '').                                                                      # Ditch the anchors
+          gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}').                                                             # All {2} become {2,2} and ? become {0,1}
+          gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                # [12]{1,2} becomes [12] or [12][12]
+          gsub(/(\([^\)]+\))\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
+          gsub(/(\\?.)\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
+          gsub(/\((.*?)\)/) {|match| match.gsub(/[\(\)]/, '').split('|').sample }.                                      # (this|that) becomes 'this' or 'that'
+          gsub(/\[([^\]]+)\]/) {|match| match.gsub(/(\w\-\w)/) {|range| Array(Range.new(*range.split('-'))).sample } }. # All A-Z inside of [] become C (or X, or whatever)
+          gsub(/\[([^\]]+)\]/) {|match| $1.split('').sample }.                                                          # All [ABC] become B (or A or C)
+          gsub('\d') {|match| Numbers.sample }.
+          gsub('\w') {|match| Letters.sample }
+      end
+
+      # Helper for the common approach of grabbing a translation
+      # with an array of values and selecting one of them.
+      def fetch(key)
+        fetched = translate("faker.#{key}")
+        fetched = fetched.sample if fetched.respond_to?(:sample)
+        if fetched.match(/^\//) and fetched.match(/\/$/) # A regex
+          regexify(fetched)
+        else
+          fetched
+        end
+      end
+
+      # Load formatted strings from the locale, "parsing" them
+      # into method calls that can be used to generate a
+      # formatted translation: e.g., "#{first_name} #{last_name}".
+      def parse(key)
+        fetch(key).scan(/(\(?)#\{([A-Za-z]+\.)?([^\}]+)\}([^#]+)?/).map {|prefix, kls, meth, etc|
+          # If the token had a class Prefix (e.g., Name.first_name)
+          # grab the constant, otherwise use self
+          cls = kls ? Faker.const_get(kls.chop) : self
+
+          # If an optional leading parentheses is not present, prefix.should == "", otherwise prefix.should == "("
+          # In either case the information will be retained for reconstruction of the string.
+          text = prefix
+
+          # If the class has the method, call it, otherwise
+          # fetch the transation (i.e., faker.name.first_name)
+          text += cls.respond_to?(meth) ? cls.send(meth) : fetch("#{(kls || self).to_s.split('::').last.downcase}.#{meth.downcase}")
+
+          # And tack on spaces, commas, etc. left over in the string
+          text += etc.to_s
+        }.join
+      end
+
+      # Call I18n.translate with our configured locale if no
+      # locale is specified
+      def translate(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts[:locale] ||= Faker::Config.locale
+        opts[:raise] = true
+        I18n.translate(*(args.push(opts)))
+      rescue I18n::MissingTranslationData
+        # Super-simple fallback -- fallback to en if the
+        # translation was missing.  If the translation isn't
+        # in en either, then it will raise again.
+        I18n.translate(*(args.push(opts.merge(:locale => :en))))
+      end
+
+      def flexible(key)
+        @flexible_key = key
+      end
+
+      # You can add whatever you want to the locale file, and it will get caught here.
+      # E.g., in your locale file, create a
+      #   name:
+      #     girls_name: ["Alice", "Cheryl", "Tatiana"]
+      # Then you can call Faker::Name.girls_name and it will act like #first_name
+      def method_missing(m, *args, &block)
+        super unless @flexible_key
+
+        # Use the alternate form of translate to get a nil rather than a "missing translation" string
+        if translation = translate(:faker)[@flexible_key][m]
+          translation.respond_to?(:sample) ? translation.sample : translation
+        else
+          super
+        end
+      end
+
+      # Generates a random value between the interval
+      def rand_in_range(from, to)
+        from, to = to, from if to < from
+        Random.new.rand(from..to)
+      end
+    end
+  end
+end
+
+require_relative 'faker/company'
+require_relative 'faker/hacker'
+
+require_relative 'extensions/array'
+require_relative 'extensions/symbol'

data/lib/garcon/utility/faker/faker/company.rb

@@ -0,0 +1,17 @@
+module Faker
+  class Company < Base
+    flexible :company
+
+    class << self
+      # Generate a buzzword-laden catch phrase.
+      def catch_phrase
+        translate('faker.company.buzzwords').collect {|list| list.sample }.join(' ')
+      end
+
+      # When a straight answer won't do, BS to the rescue!
+      def bs
+        translate('faker.company.bs').collect {|list| list.sample }.join(' ')
+      end
+    end
+  end
+end

data/lib/garcon/utility/faker/faker/hacker.rb

@@ -0,0 +1,30 @@
+
+module Faker
+  class Hacker < Base
+    flexible :hacker
+
+    class << self
+      def say_something_smart
+        phrases.sample
+      end
+
+      def abbreviation;  fetch('hacker.abbreviation'); end
+      def adjective;     fetch('hacker.adjective'); end
+      def noun;          fetch('hacker.noun'); end
+      def verb;          fetch('hacker.verb'); end
+      def ingverb;       fetch('hacker.ingverb'); end
+
+      def phrases
+         [ "If we #{verb} the #{noun}, we can get to the #{abbreviation} #{noun} through the #{adjective} #{abbreviation} #{noun}!",
+           "We need to #{verb} the #{adjective} #{abbreviation} #{noun}!",
+           "Try to #{verb} the #{abbreviation} #{noun}, maybe it will #{verb} the #{adjective} #{noun}!",
+           "You can't #{verb} the #{noun} without #{ingverb} the #{adjective} #{abbreviation} #{noun}!",
+           "Use the #{adjective} #{abbreviation} #{noun}, then you can #{verb} the #{adjective} #{noun}!",
+           "The #{abbreviation} #{noun} is down, #{verb} the #{adjective} #{noun} so we can #{verb} the #{abbreviation} #{noun}!",
+           "#{ingverb} the #{noun} won't do anything, we need to #{verb} the #{adjective} #{abbreviation} #{noun}!",
+           "I'll #{verb} the #{adjective} #{abbreviation} #{noun}, that should #{noun} the #{abbreviation} #{noun}!"
+           ]
+      end
+    end
+  end
+end

data/lib/garcon/utility/faker/faker/version.rb

@@ -0,0 +1,3 @@
+module Faker #:nodoc:
+  VERSION = "1.4.3"
+end

data/lib/garcon/utility/faker/locales/en-US.yml

@@ -0,0 +1,83 @@
+en-US:
+  faker:
+    internet:
+      domain_suffix: [com, us, biz, info, name, net, org]
+    address:
+      default_country: [United States, United States of America, USA]
+      postcode_by_state:
+        AL: '350##'
+        AK: '995##'
+        AS: '967##'
+        AZ: '850##'
+        AR: '717##'
+        CA: '900##'
+        CO: '800##'
+        CT: '061##'
+        DC: '204##'
+        DE: '198##'
+        FL: '322##'
+        GA: '301##'
+        HI: '967##'
+        ID: '832##'
+        IL: '600##'
+        IN: '463##'
+        IA: '510##'
+        KS: '666##'
+        KY: '404##'
+        LA: '701##'
+        ME: '042##'
+        MD: '210##'
+        MA: '026##'
+        MI: '480##'
+        MN: '555##'
+        MS: '387##'
+        MO: '650##'
+        MT: '590##'
+        NE: '688##'
+        NV: '898##'
+        NH: '036##'
+        NJ: '076##'
+        NM: '880##'
+        NY: '122##'
+        NC: '288##'
+        ND: '586##'
+        OH: '444##'
+        OK: '730##'
+        OR: '979##'
+        PA: '186##'
+        RI: '029##'
+        SC: '299##'
+        SD: '577##'
+        TN: '383##'
+        TX: '798##'
+        UT: '847##'
+        VT: '050##'
+        VA: '222##'
+        WA: '990##'
+        WV: '247##'
+        WI: '549##'
+        WY: '831##'
+    phone_number:
+      area_code: ["201", "202", "203", "205", "206", "207", "208", "209", "210", "212", "213", "214", "215", "216", "217", "218", "219", "224", "225", "227", "228", "229", "231", "234", "239", "240", "248", "251", "252", "253", "254", "256", "260", "262", "267", "269", "270", "276", "281", "283", "301", "302", "303", "304", "305", "307", "308", "309", "310", "312", "313", "314", "315", "316", "317", "318", "319", "320", "321", "323", "330", "331", "334", "336", "337", "339", "347", "351", "352", "360", "361", "386", "401", "402", "404", "405", "406", "407", "408", "409", "410", "412", "413", "414", "415", "417", "419", "423", "424", "425", "434", "435", "440", "443", "445", "464", "469", "470", "475", "478", "479", "480", "484", "501", "502", "503", "504", "505", "507", "508", "509", "510", "512", "513", "515", "516", "517", "518", "520", "530", "540", "541", "551", "557", "559", "561", "562", "563", "564", "567", "570", "571", "573", "574", "580", "585", "586", "601", "602", "603", "605", "606", "607", "608", "609", "610", "612", "614", "615", "616", "617", "618", "619", "620", "623", "626", "630", "631", "636", "641", "646", "650", "651", "660", "661", "662", "667", "678", "682", "701", "702", "703", "704", "706", "707", "708", "712", "713", "714", "715", "716", "717", "718", "719", "720", "724", "727", "731", "732", "734", "737", "740", "754", "757", "760", "763", "765", "770", "772", "773", "774", "775", "781", "785", "786", "801", "802", "803", "804", "805", "806", "808", "810", "812", "813", "814", "815", "816", "817", "818", "828", "830", "831", "832", "835", "843", "845", "847", "848", "850", "856", "857", "858", "859", "860", "862", "863", "864", "865", "870", "872", "878", "901", "903", "904", "906", "907", "908", "909", "910", "912", "913", "914", "915", "916", "917", "918", "919", "920", "925", "928", "931", "936", "937", "940", "941", "947", "949", "952", "954", "956", "959", "970", "971", "972", "973", "975", "978", "979", "980", "984", "985", "989"]
+      exchange_code: ["201", "202", "203", "205", "206", "207", "208", "209", "210", "212", "213", "214", "215", "216", "217", "218", "219", "224", "225", "227", "228", "229", "231", "234", "239", "240", "248", "251", "252", "253", "254", "256", "260", "262", "267", "269", "270", "276", "281", "283", "301", "302", "303", "304", "305", "307", "308", "309", "310", "312", "313", "314", "315", "316", "317", "318", "319", "320", "321", "323", "330", "331", "334", "336", "337", "339", "347", "351", "352", "360", "361", "386", "401", "402", "404", "405", "406", "407", "408", "409", "410", "412", "413", "414", "415", "417", "419", "423", "424", "425", "434", "435", "440", "443", "445", "464", "469", "470", "475", "478", "479", "480", "484", "501", "502", "503", "504", "505", "507", "508", "509", "510", "512", "513", "515", "516", "517", "518", "520", "530", "540", "541", "551", "557", "559", "561", "562", "563", "564", "567", "570", "571", "573", "574", "580", "585", "586", "601", "602", "603", "605", "606", "607", "608", "609", "610", "612", "614", "615", "616", "617", "618", "619", "620", "623", "626", "630", "631", "636", "641", "646", "650", "651", "660", "661", "662", "667", "678", "682", "701", "702", "703", "704", "706", "707", "708", "712", "713", "714", "715", "716", "717", "718", "719", "720", "724", "727", "731", "732", "734", "737", "740", "754", "757", "760", "763", "765", "770", "772", "773", "774", "775", "781", "785", "786", "801", "802", "803", "804", "805", "806", "808", "810", "812", "813", "814", "815", "816", "817", "818", "828", "830", "831", "832", "835", "843", "845", "847", "848", "850", "856", "857", "858", "859", "860", "862", "863", "864", "865", "870", "872", "878", "901", "903", "904", "906", "907", "908", "909", "910", "912", "913", "914", "915", "916", "917", "918", "919", "920", "925", "928", "931", "936", "937", "940", "941", "947", "949", "952", "954", "956", "959", "970", "971", "972", "973", "975", "978", "979", "980", "984", "985", "989"]
+      formats:
+        - "#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number}"
+        - "(#{PhoneNumber.area_code}) #{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number}"
+        - "1-#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number}"
+        - "#{PhoneNumber.area_code}.#{PhoneNumber.exchange_code}.#{PhoneNumber.subscriber_number}"
+        - "#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number}"
+        - "(#{PhoneNumber.area_code}) #{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number}"
+        - "1-#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number}"
+        - "#{PhoneNumber.area_code}.#{PhoneNumber.exchange_code}.#{PhoneNumber.subscriber_number}"
+        - "#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "(#{PhoneNumber.area_code}) #{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "1-#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "#{PhoneNumber.area_code}.#{PhoneNumber.exchange_code}.#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "(#{PhoneNumber.area_code}) #{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "1-#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "#{PhoneNumber.area_code}.#{PhoneNumber.exchange_code}.#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "(#{PhoneNumber.area_code}) #{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "1-#{PhoneNumber.area_code}-#{PhoneNumber.exchange_code}-#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"
+        - "#{PhoneNumber.area_code}.#{PhoneNumber.exchange_code}.#{PhoneNumber.subscriber_number} x#{PhoneNumber.extension}"