nifty-utils 1.0.5 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19691448dc81e33142b1040ffc060db38e0d88c3
-  data.tar.gz: e24d62684fc507a06d9f5b23cb993953b115b3d7
+  metadata.gz: 0f43ab7bf985adc936f4f3d5af7d9aeed18f5874
+  data.tar.gz: 8f219e2ad9b79506674ab44989fd62c281d8b933
 SHA512:
-  metadata.gz: 8ee820646005e012ebf402eb2ebbcf5c669005135339c1c83d56066bddb40fdc56cc3e3baf3b4cda943d51a3b03f6cb7eae376565eefe729a54a542a858cd449
-  data.tar.gz: 44a944e51676bdda63e8bc681eeaab061dee98d41dabe0729988d54a88917646a4be3f0a665f10058db908e83bf623c8cecdfc8a737d4dcf61798536396ca08d
+  metadata.gz: 01e12d189131662b24b3b31e0c17eb94d339b68fd419e8eaecb4d6a43551d369297cbf3d7c45cd6d58b65898e15b399d0be54a09c52d87436eab365be939e8bf
+  data.tar.gz: fe8b782a9f0538d2764b954b4fdc25ba23b5f2dee681859d801745cbbca1b1b45389ea9dc1c5f11b9c96631d8291fb5de237215f60a35fedeec78306d6c4a9d3

data/lib/nifty/utils/active_record/default_value.rb

@@ -0,0 +1,56 @@
+module Nifty
+  module Utils
+    module ActiveRecord
+      module DefaultValue
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+
+          def has_default_values?
+            false
+          end
+
+          def default_value(field, block, options = {})
+            self.send :include, ModelExtensions unless self.has_default_values?
+            self.default_value_definitions[field] = options.merge(:block => block)
+          end
+
+        end
+
+        module ModelExtensions
+
+          def self.included(base)
+            base.extend ClassMethods
+            base.before_validation :_set_default_values
+          end
+
+          def _set_default_values
+            self.class.default_value_definitions.each do |field, opts|
+              if self.send(field).blank?
+                proposed_value = self.instance_exec(&opts[:block])
+                self.send("#{field}=", proposed_value)
+              end
+            end
+          end
+
+          module ClassMethods
+
+            def default_value_definitions
+              @default_value_definitions ||= {}
+            end
+
+            def has_default_values?
+              true
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/nifty/utils/active_record/inquirer.rb

@@ -0,0 +1,40 @@
+module Nifty
+  module Utils
+    module ActiveRecord
+      module Inquirer
+
+        #:nodoc:
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+
+          # Allows you to automatically create inquiry methods for string field. For example, if you have
+          # an Order model which has a status field containing 'approved' or 'delivered' you may wish to
+          # have a #approved? or #delivered? method on the model.
+          #
+          #   class Order < ActiveRecord::Baser
+          #     STATUSES = ['approved', 'delivered']
+          #     inquirer :status, *STATUSES
+          #   end
+          #
+          #   order = Order.new(:status => 'approved')
+          #   order.approved?       #=> true
+          #   order.delivered?      #=> false
+          #
+          #
+          def inquirer(field, *options)
+            options.each do |option|
+              define_method "#{option}?" do
+                self.read_attribute(field).to_s == option.to_s
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/nifty/utils/active_record/random_string.rb

@@ -0,0 +1,77 @@
+require 'securerandom'
+require 'nifty/utils/random_string'
+
+module Nifty
+  module Utils
+    module ActiveRecord
+      module RandomString
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        def self.random_string(type, opts = {})
+          case type.to_sym
+          when :uuid
+            SecureRandom.uuid
+          when :chars
+            Nifty::Utils::RandomString.generate(opts)
+          else
+            SecureRandom.hex(opts[:length] || 24)
+          end
+        end
+
+        module ClassMethods
+
+          def has_random_strings?
+            false
+          end
+
+          def random_string(field, options = {})
+            self.send :include, ModelExtensions unless self.has_random_strings?
+            self.random_string_fields[field] = options
+          end
+
+        end
+
+        module ModelExtensions
+
+          def self.included(base)
+            base.extend ClassMethods
+            base.before_validation :generate_random_strings
+          end
+
+          def generate_random_strings
+            self.class.random_string_fields.each do |field, opts|
+              if self.send(field).blank?
+                if opts[:unique]
+                  until self.send(field)
+                    proposed_string = RandomString.random_string(opts[:type], opts)
+                    unless self.class.where(field => proposed_string).exists?
+                      self.send("#{field}=", proposed_string)
+                    end
+                  end
+                else
+                  self.send("#{field}=", RandomString.random_string(opts[:type], opts))
+                end
+              end
+            end
+          end
+
+          module ClassMethods
+
+            def random_string_fields
+              @random_string_fields ||= {}
+            end
+
+            def has_random_strings?
+              true
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/nifty/utils/auto_attribute_permit.rb

@@ -0,0 +1,70 @@
+module Nifty
+  module Utils
+    module AutoAttributePermit
+
+      def self.setup
+        ActionView::Helpers::FormBuilder.send :include, FormBuilderExtensions
+        ActionController::Parameters.send :include, StrongParameterExtensions
+      end
+
+      def self.verifier
+        @verifier ||= ActiveSupport::MessageVerifier.new(Rails.application.secrets.secret_key_base)
+      end
+
+      module StrongParameterExtensions
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :permit, :auto_attribute_permit
+          end
+        end
+
+        def permit_with_auto_attribute_permit(*filters)
+          if filters.delete(:auto)
+            fields = AutoAttributePermit.verifier.verify(self['permitted_fields'])
+            permit_without_auto_attribute_permit(*(fields | filters))
+          else
+            permit_without_auto_attribute_permit(*filters)
+          end
+        end
+      end
+
+      module FormBuilderExtensions
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :label, :auto_attribute_permit
+            alias_method_chain :submit, :auto_attribute_permit
+          end
+        end
+
+        def auto_permitted_attributes
+          @auto_permitted_attributes ||= []
+        end
+
+        def label_with_auto_attribute_permit(method, text = nil, options = {}, &block)
+          auto_permitted_attributes << method unless (text.is_a?(Hash) ? text : options)[:auto_permit] == false
+          label_without_auto_attribute_permit(method, text, options, &block)
+        end
+
+        def submit_with_auto_attribute_permit(value = nil, options = {})
+          value, options = nil, value if value.is_a?(Hash)
+          include_permit_field = options.delete(:include_auto_permit_field)
+          submit_button = submit_without_auto_attribute_permit(value, options)
+          unless include_permit_field == false
+            submit_button.safe_concat(self.auto_permitted_attributes_field)
+          else
+            submit_button
+          end
+        end
+
+        def encoded_auto_permitted_attributes
+          AutoAttributePermit.verifier.generate(auto_permitted_attributes)
+        end
+
+        def auto_permitted_attributes_field
+          @template.hidden_field_tag("#{@object_name}[permitted_fields]", encoded_auto_permitted_attributes)
+        end
+      end
+
+    end
+  end
+end

data/lib/nifty/utils/extensions/core.rb

@@ -1 +1,2 @@
-require 'nifty/utils/extensions/string'
+require 'nifty/utils/extensions/object'
+require 'nifty/utils/extensions/string'

data/lib/nifty/utils/extensions/object.rb

@@ -0,0 +1,9 @@
+require 'nifty/utils/until_with_max_attempts'
+
+class Object
+
+  def until_with_max_attempts(*args,  &block)
+    Nifty::Utils::UntilWithMaxAttempts.until(*args, &block)
+  end
+
+end

data/lib/nifty/utils/extensions/string.rb

@@ -1,7 +1,7 @@
 require 'nifty/utils/random_string'
 
 class String
-  
+
   def self.random(options = {})
     Nifty::Utils::RandomString.generate(options)
   end
@@ -9,17 +9,21 @@ class String
   def ansi(code)
     "\e[#{code.to_s}m#{self}\e[0m"
   end
-  
+
   def red
     self.ansi(31)
   end
-  
+
   def green
     self.ansi(32)
   end
-  
-  def yello
+
+  def yellow
     self.ansi(33)
   end
-  
+
+  def blue
+    self.ansi(34)
+  end
+
 end

data/lib/nifty/utils/http.rb

@@ -0,0 +1,78 @@
+require 'net/https'
+require 'uri'
+
+module Nifty
+  module Utils
+    module HTTP
+
+      def self.get(url, options = {})
+        request(Net::HTTP::Get, url, options)
+      end
+
+      def self.post(url, options = {})
+        request(Net::HTTP::Post, url, options)
+      end
+
+      def self.request(method, url, options = {})
+        options[:headers] ||= {}
+        uri = URI.parse(url)
+        request = method.new(uri.path.length == 0 ? "/" : uri.path)
+        options[:headers].each { |k,v| request.add_field k, v }
+
+        if options[:username]
+          request.basic_auth(options[:username], options[:password])
+        end
+
+        if options[:params].is_a?(Hash)
+          # If params has been provided, sent it them as form encoded values
+          request.set_form_data(options[:params])
+
+        elsif options[:json].is_a?(String)
+          # If we have a JSON string, set the content type and body to be the JSON
+          # data
+          request.add_field 'Content-Type', 'application/json'
+          request.body = options[:json]
+        end
+
+        if options[:user_agent]
+          request['User-Agent'] = options[:user_agent]
+        end
+
+        connection = Net::HTTP.new(uri.host, uri.port)
+
+        if uri.scheme == 'https'
+          connection.use_ssl = true
+          connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        begin
+          timeout = options[:timeout] || 60
+          Timeout.timeout(timeout) do
+            result = connection.request(request)
+            if result.content_type == 'application/json'
+              body = JSON.parse(result.body)
+            else
+              body = result.body
+            end
+            {
+              :code => result.code.to_i,
+              :type => result.content_type,
+              :body => body
+            }
+          end
+        rescue SocketError, Errno::ECONNRESET, EOFError, Errno::EINVAL => e
+          {
+            :code => -2,
+            :body => e.message
+          }
+        rescue Timeout::Error => e
+          {
+            :code => -1,
+            :body => "Timed out after #{timeout}s"
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/nifty/utils/networks.rb

@@ -0,0 +1,28 @@
+require 'ipaddr'
+
+module Nifty
+  module Utils
+    module Networks
+
+      def self.ip_in_networks?(ip, networks = [])
+        !!network_for_ip(networks, ip)
+      end
+
+      def self.network_for_ip(networks, ip)
+        networks.each do |i|
+          if IPAddr.new(i).include?(ip)
+            return i
+          end
+        end
+        return nil
+      rescue ArgumentError => e
+        if e.message == 'invalid address'
+          return nil
+        else
+          raise
+        end
+      end
+
+    end
+  end
+end

data/lib/nifty/utils/railtie.rb

@@ -1,23 +1,28 @@
 module Nifty
   module Utils
     class Railtie < Rails::Railtie #:nodoc:
-      
-      initializer 'nifty.utils.initialize' do
+
+      initializer 'nifty.utils.initialize' do |app|
+        Rails.application.config.i18n.load_path << File.expand_path(File.join('..', '..', '..', '..', 'locales', 'en.yml'), __FILE__)
 
         # Load the Active Record extensions
         ActiveSupport.on_load(:active_record) do
-          require 'nifty/utils/active_record'
-          ::ActiveRecord::Base.send :include, Nifty::Utils::ActiveRecord
+          require 'nifty/utils/active_record/inquirer'
+          ::ActiveRecord::Base.send :include, Nifty::Utils::ActiveRecord::Inquirer
+          require 'nifty/utils/active_record/random_string'
+          ::ActiveRecord::Base.send :include, Nifty::Utils::ActiveRecord::RandomString
+          require 'nifty/utils/active_record/default_value'
+          ::ActiveRecord::Base.send :include, Nifty::Utils::ActiveRecord::DefaultValue
         end
-        
+
         # load the Action View helpers
         ActiveSupport.on_load(:action_view) do
           require 'nifty/utils/view_helpers'
           ActionView::Base.send :include, Nifty::Utils::ViewHelpers
         end
-        
+
       end
-      
+
     end
   end
 end

data/lib/nifty/utils/until_with_max_attempts.rb

@@ -0,0 +1,45 @@
+module Nifty
+  module Utils
+    module UntilWithMaxAttempts
+
+      #
+      # The exception which will be raised if the maximum number of attempts
+      # is reached.
+      #
+      class MaxAttemptsReached < StandardError; end
+
+      #
+      # Like a usual while block but with a maximum attempt counter. Can be used
+      # like this
+      #
+      #    Attempts.until proc { job.completed? }, :attempts => 10, :gap => 5 do
+      #      puts "Waiting for job to complete..."
+      #    end
+      #
+      # The proc is the condition which will be evaluated, :attempts sets the
+      # maximum number of times it will wait before raising an exception and :gap
+      # is the length of time in seconds to wait between each check.
+      #
+      def self.until(condition, options = {}, &block)
+        options[:attempts] ||= 10
+        count = 0
+        until condition.call
+
+          if count == options[:attempts]
+            raise MaxAttemptsReached, "Maximum attempts reached (#{options[:attempts]}) without success"
+          end
+
+          yield
+
+          count += 1
+
+          if options[:gap] && count < options[:attempts]
+            sleep options[:gap]
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/nifty/utils/version.rb

@@ -1,5 +1,5 @@
 module Nifty
   module Utils
-    VERSION = '1.0.5'
+    VERSION = '1.1.7'
   end
 end

data/lib/nifty/utils/view_helpers.rb

@@ -1,21 +1,24 @@
 module Nifty
   module Utils
     module ViewHelpers
-      
+
       # Displays the full contents of the `flash` hash within an appropriate <div>
       # element. The ID of the outputted div will be `flash-alert` where alert is the
-      # type of flash. 
+      # type of flash.
       #
-      # If there are multiple flashes set, they will all be displayed.
-      def display_flash
-        flashes = flash.collect do |key,msg|
-          content_tag :div, content_tag(:p, h(msg)), :id => "flash-#{key}"
+      # * <tt>:types</tt>: the names of flash messages to display with this helper
+      def display_flash(options = {})
+        options[:types] ||= [:alert, :warning, :notice]
+        options[:types].map do |key|
+          if flash[key]
+            content_tag :div, content_tag(:p, h(flash[key])), :id => "flash-#{key}", :class => "flashMessage flashMessage--#{key}"
+          end
         end.join.html_safe
       end
-      
+
       # Renders an `<img>` containing a link to the gravatar for the given e-mail address.
       # Available options as follows:
-      # 
+      #
       # * <tt>:size</tt>: the size in pixels of the outputted gravatar. Defaults to 35.
       # * <tt>:default</tt>: the gravatar to fallback to if the user has no gravatar
       #   (see gravatar for available options or pass a URL). Defaults to 'identicon'.
@@ -34,10 +37,10 @@ module Nifty
         path = "/avatar.php?gravatar_id=#{Digest::MD5.hexdigest(email.to_s.downcase)}&rating=#{options[:rating]}&size=#{options[:size] * 2}&d=#{options[:default]}"
         image_tag([host,path].join, :class => options[:class], :width => options[:size], :height => options[:size])
       end
-      
+
       # Renders a tick or cross character based on the provided boolean. Additional options
       # can be passed if needed.
-      # 
+      #
       # * <tt>:true_text</tt> - text to display next to a tick
       # * <tt>:false_text</tt> - text to display next to a cross
       def boolean_tag(bool, tip = nil, options = {})
@@ -46,7 +49,53 @@ module Nifty
         false_text = " <b>#{options[:false_text]}</b>" if options[:false_text]
         content_tag :span, (bool ? "<span class='true'>&#x2714;#{true_text}</span>" : "<span class='false'>&#x2718;#{false_text}</span>").html_safe, :class => "boolean", :title => tip
       end
-      
+
+      # Returns a URL to share some content on Twitter
+      #
+      # * <tt>:text</tt> - the text you wish to tweet
+      # * <tt>:url</tt> - the URL you want to tweet
+      def twitter_share_url(options = {})
+        "https://twitter.com/share?text=#{CGI.escape(options[:text])}&url=#{CGI.escape(options[:url])}"
+      end
+
+      # Returns a length of time in works (no I18N)
+      #
+      def length_of_time_in_words(seconds, options = {})
+        days = (seconds / 60 / 60 / 24).floor
+        hours = ((seconds / 60 / 60) - (days * 24)).floor
+        minutes = ((seconds / 60) - (days * 24 * 60) - (hours * 60)).floor
+        seconds = (seconds - (days * 24 * 60 * 60) - (hours * 60 * 60) - (minutes * 60)).floor
+        Array.new.tap do |s|
+          if options[:short]
+            s << "#{days}d" if days > 0
+            s << "#{hours}h" if hours > 0
+            s << "#{minutes}m" if minutes > 0
+            s << "#{seconds}s" if seconds > 0
+          else
+            s << pluralize(days, 'day') if days > 0
+            s << pluralize(hours, 'hour') if hours > 0
+            s << pluralize(minutes, 'minute') if minutes > 0
+            s << pluralize(seconds, 'second') if seconds > 0
+          end
+        end.join(options[:short] ? ' ' : ', ')
+      end
+
+      # Return an image path for an RFC4226 QR code for a tiven RTP token
+      def rfc4226_qrcode(token)
+        data = "otpauth://totp/#{request.host}?secret=#{token}"
+        data = Rack::Utils.escape(data)
+        url = "https://chart.googleapis.com/chart?chs=200x200&chld=M|0&cht=qr&chl=#{data}"
+        image_tag(url, :alt => 'Google Authenticator QRCode', :width => 200, :height => 200)
+      end
+
+      # Return a Google Fonts tag
+      def google_fonts(sets = {})
+        sets = sets.each_with_object([]) do |(name, weights), array|
+          array << "#{name}:#{weights.join(',')}"
+        end.join('|')
+        "<link href='https://fonts.googleapis.com/css?family=#{sets}' rel='stylesheet' type='text/css'>".html_safe
+      end
+
     end
   end
 end

data/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  nifty-utils:
+    hello: Hello world!
+

metadata

@@ -1,32 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: nifty-utils
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.7
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-24 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies: []
-description: A set of useful utilties for Rails applications
+description: A set of useful utilties for Rails applications.
 email:
-- adam@niftyware.io
+- adam@atechmedia.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/nifty/utils.rb
-- lib/nifty/utils/active_record.rb
+- lib/nifty/utils/active_record/default_value.rb
+- lib/nifty/utils/active_record/inquirer.rb
+- lib/nifty/utils/active_record/random_string.rb
+- lib/nifty/utils/auto_attribute_permit.rb
 - lib/nifty/utils/extensions/core.rb
+- lib/nifty/utils/extensions/object.rb
 - lib/nifty/utils/extensions/string.rb
+- lib/nifty/utils/http.rb
+- lib/nifty/utils/networks.rb
 - lib/nifty/utils/railtie.rb
 - lib/nifty/utils/random_string.rb
+- lib/nifty/utils/until_with_max_attempts.rb
 - lib/nifty/utils/version.rb
 - lib/nifty/utils/view_helpers.rb
-homepage: https://github.com/niftyware/utils
-licenses: []
+- locales/en.yml
+homepage: https://github.com/atech/nifty-utils
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -44,9 +53,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: A set of useful utilties for Rails applications
+summary: A collection of functions which expand upon ActiveRecord and ActionView.
 test_files: []
-has_rdoc: 

data/lib/nifty/utils/active_record.rb

@@ -1,38 +0,0 @@
-module Nifty
-  module Utils
-    module ActiveRecord
-      
-      #:nodoc:
-      def self.included(base)
-        base.extend ClassMethods
-      end
-      
-      module ClassMethods
-        
-        # Allows you to automatically create inquiry methods for string field. For example, if you have
-        # an Order model which has a status field containing 'approved' or 'delivered' you may wish to 
-        # have a #approved? or #delivered? method on the model. 
-        #
-        #   class Order < ActiveRecord::Baser
-        #     STATUSES = ['approved', 'delivered']
-        #     inquirer :status, *STATUSES
-        #   end
-        #
-        #   order = Order.new(:status => 'approved')
-        #   order.approved?       #=> true
-        #   order.delivered?      #=> false
-        # 
-        #     
-        def inquirer(field, *options)
-          options.each do |option|
-            define_method "#{option}?" do 
-              self.read_attribute(field).to_s == option.to_s
-            end
-          end
-        end
-        
-      end
-      
-    end
-  end
-end