incline 0.1.5

data/lib/incline/extensions/jbuilder_template.rb

@@ -0,0 +1,39 @@
+require 'jbuilder/jbuilder_template'
+
+module Incline::Extensions
+  ##
+  # Adds the +api_errors+ method to be used in jbuilder views to easily list
+  # errors for a model in a form that is compatible with the DataTables API.
+  module JbuilderTemplate
+
+    ##
+    # List out the errors for the model.
+    #
+    # model_name::   The singular name for the model (e.g. - "user_account")
+    # model_errors:: The errors collection from the model.
+    #
+    #   json.api_errors! "user_account", user.errors
+    #
+    def api_errors!(model_name, model_errors)
+      base_error = model_errors[:base]
+      field_errors = model_errors.reject{ |k,_| k == :base }
+      unless base_error.blank?
+        set! 'error', "#{model_name.humanize} #{base_error.map{|e| h(e.to_s)}.join("<br>\n#{model_name.humanize} ")}"
+      end
+      unless field_errors.blank?
+        set! 'fieldErrors' do
+          array! field_errors do |k,v|
+            set! 'name',   "#{model_name}.#{k}"
+            set! 'status', v.is_a?(::Array) ?
+                "#{k.to_s.humanize} #{v.map{|e| h(e.to_s)}.join("<br>\n#{k.to_s.humanize} ")}" :
+                "#{k.to_s.humanize} #{h v.to_s}"
+          end
+        end
+      end
+    end
+
+  end
+end
+
+JbuilderTemplate.include Incline::Extensions::JbuilderTemplate
+

data/lib/incline/extensions/main_app.rb

@@ -0,0 +1,40 @@
+require 'action_controller'
+require 'action_mailer'
+require 'action_view'
+
+module Incline::Extensions
+
+  ##
+  # Makes 'main_app' automatically get searched for methods.
+  module MainApp
+
+    def self.included(base) # :nodoc:
+      base.class_eval do
+
+        # :nodoc:
+        alias :incline_mainapp_original_method_missing :method_missing
+
+        def method_missing(method, *args, &block) # :nodoc:
+          o_main_app = if respond_to?(:main_app)
+                         send(:main_app)
+                       else
+                         Rails.application.class.routes.url_helpers
+                       end
+          
+          if o_main_app && o_main_app.respond_to?(method)
+            return o_main_app.send(method, *args, &block)
+          end
+          
+          incline_mainapp_original_method_missing(method, *args, &block)
+        end
+
+      end
+    end
+
+  end
+
+end
+
+ActionController::Base.include Incline::Extensions::MainApp
+ActionMailer::Base.include Incline::Extensions::MainApp
+ActionView::Base.include Incline::Extensions::MainApp

data/lib/incline/extensions/numeric.rb

@@ -0,0 +1,63 @@
+require 'bigdecimal'
+
+module Incline::Extensions
+  ##
+  # Adds to_human to numeric types (floats and integers).
+  module Numeric
+
+    ##
+    # The short scale for humanizing a number.
+    SHORT_SCALE =
+        [
+            [ Integer('1'.ljust(40,'0')), 'duodecillion' ],
+            [ Integer('1'.ljust(37,'0')), 'undecillion' ],
+            [ Integer('1'.ljust(34,'0')), 'decillion' ],
+            [ Integer('1'.ljust(31,'0')), 'nonillion' ],
+            [ Integer('1'.ljust(28,'0')), 'octilillion' ],
+            [ Integer('1'.ljust(25,'0')), 'septillion' ],
+            [ Integer('1'.ljust(22,'0')), 'sextillion' ],
+            [ Integer('1'.ljust(19,'0')), 'quintillion' ],
+            [ Integer('1'.ljust(16,'0')), 'quadrillion' ],
+            [ Integer('1'.ljust(13,'0')), 'trillion' ],
+            [ Integer('1'.ljust(10,'0')), 'billion' ],
+            [ Integer('1'.ljust(7,'0')), 'million' ],
+            [ Integer('1'.ljust(4,'0')), 'thousand' ],
+        ]
+
+    ##
+    # Formats the number using the short scale for any number over 1 million.
+    def to_human
+      Incline::Extensions::Numeric::SHORT_SCALE.each do |(num,label)|
+        if self >= num
+          # Add 0.0001 to the value before rounding it off.
+          # This way we're telling the system that we want it to round up instead of round to even.
+          s = ('%.2f' % ((self.to_f / num) + 0.0001)).gsub(/\.?0+\z/,'')
+          return "#{s} #{label}"
+        end
+      end
+
+      if self.is_a?(::Rational)
+        if self.denominator == 1
+          return self.numerator.to_s
+        end
+        return self.to_s
+      elsif self.is_a?(::Integer)
+        return self.to_s
+      end
+
+      # Again we want to add the 0.0001 to the value before rounding.
+      ('%.2f' % (self.to_f + 0.0001)).gsub(/\.?0+\z/,'')
+    end
+
+    ##
+    # Converts this value into a boolean.
+    #
+    # A value of 0 is false, any other value is true.
+    def to_bool
+      self != 0
+    end
+
+  end
+end
+
+Numeric.include Incline::Extensions::Numeric

data/lib/incline/extensions/object.rb

@@ -0,0 +1,31 @@
+module Incline::Extensions
+
+  ##
+  # Adds the +object_pointer+ method to all objects.
+  module Object
+
+    ##
+    # Gets the object_id formatted in hexadecimal with a leading '0x'.
+    def object_pointer
+      '0x' + self.object_id.to_s(16).rjust(12,'0').downcase
+    end
+
+    ##
+    # Converts this object into a boolean value.
+    #
+    # The +true+ value returns true, as do the :true, :yes, and :on symbols.
+    # Any numeric not equal to 0 returns true.
+    # And the strings of 'true', 't', 'yes', 'y', 'on', and '1' (case-insensitive) return true.
+    # Everything else will return false, including +nil+.
+    #
+    # This obviously differs from the Ruby behavior that only nil and false evaluate to false.
+    # This is not meant to replace that behavior, it was actually meant to enable simple usage of
+    # other values commonly used to the represent true and false (eg - 0 and 1).
+    def to_bool
+      is_a?(::TrueClass) || self == :true || self == :yes || self == :on
+    end
+
+  end
+end
+
+Object.include Incline::Extensions::Object

data/lib/incline/extensions/resource_route_generator.rb

@@ -0,0 +1,53 @@
+require 'rails/generators'
+require 'rails/generators/rails/resource_route/resource_route_generator'
+
+module Incline::Extensions
+  module ResourceRouteGenerator
+
+    ##
+    # Overrides the add_resource_route method.
+    def self.included(base)
+      base.class_eval do
+        undef add_resource_route
+
+        ##
+        # Adds a resource route with additional :api and :locate actions.
+        def add_resource_route
+          return if options[:actions].present?
+
+          # iterates over all namespaces and opens up blocks
+          regular_class_path.each_with_index do |namespace, index|
+            write("namespace :#{namespace} do", index + 1)
+          end
+
+          # inserts the primary resource with api routes as well.
+          pad = '  ' * (route_length + 1)
+          write <<-EOR, 0
+#{pad}resources :#{file_name.pluralize} do
+#{pad}  member do
+#{pad}    post :locate
+#{pad}  end
+#{pad}  collection do
+#{pad}    match :api, via: [ :get, :post ]
+#{pad}  end
+#{pad}end
+          EOR
+
+          # ends blocks
+          regular_class_path.each_index do |index|
+            write("end", route_length - index)
+          end
+
+          # route prepends two spaces onto the front of the string that is passed, this corrects that.
+          # Also it adds a \n to the end of each line, as route already adds that
+          # we need to correct that too.
+          route route_string[2..-2]
+        end
+
+      end
+    end
+
+  end
+end
+
+Rails::Generators::ResourceRouteGenerator.include Incline::Extensions::ResourceRouteGenerator

data/lib/incline/extensions/session.rb

@@ -0,0 +1,113 @@
+require 'action_view'
+require 'action_controller'
+require 'action_mailer'
+require 'action_dispatch'
+
+module Incline::Extensions
+
+  ##
+  # Patches the views and controllers to have access to user session features.
+  module Session
+
+    ##
+    # Contains the methods common to both controllers and views.
+    module Common
+
+      ##
+      # Gets the name of the cookie containing the user ID for the current user.
+      #
+      # This gets set when the user selects the "Remember me" checkbox when logging in.
+      def user_id_cookie
+        @user_id_cookie ||= Rails.application.cookie_name(:user_id)
+      end
+
+      ##
+      # Gets the name of the cookie containing the remember token for the current user.
+      #
+      # This gets set when the user selects the "Remember me" checkbox when logging in.
+      def user_token_cookie
+        @user_token_cookie ||= Rails.application.cookie_name(:user_token)
+      end
+
+      ##
+      # Gets the currently logged in user.
+      def current_user
+        @current_user ||=
+            if (user_id = session[:user_id])
+              Incline::User.find_by(id: user_id)
+            elsif (cookies&.respond_to?(:signed)) &&
+                (user_id = cookies.signed[user_id_cookie]) &&
+                (user = Incline::User.find_by(id: user_id)) &&
+                (user.authenticated?(:remember, cookies[user_token_cookie]))
+              log_in user if respond_to?(:log_in)
+              user
+            else
+              nil
+            end ||Incline::User::anonymous
+      end
+
+      ##
+      # Is the specified user the current user?
+      def current_user?(user)
+        current_user == user
+      end
+
+      ##
+      # Is a user logged in?
+      def logged_in?
+        !current_user.anonymous?
+      end
+
+      ##
+      # Is the current user a system administrator?
+      def system_admin?
+        logged_in? && current_user.system_admin? && current_user.enabled? && current_user.activated?
+      end
+
+    end
+
+    ##
+    # Contains the methods specific to controllers.
+    module Controller
+
+      ##
+      # Logs in the given user.
+      def log_in(user)
+        session[:user_id] = user.id
+      end
+
+      ##
+      # Logs out any currently logged in user.
+      def log_out
+        forget current_user
+        session.delete(:user_id)
+        @current_user = nil
+      end
+
+      ##
+      # Stores the user ID to the permanent cookie store to keep the user logged in.
+      def remember(user)
+        user.remember
+        cookies.permanent.signed[user_id_cookie] = user.id
+        cookies.permanent[user_token_cookie] = user.remember_token
+      end
+
+      ##
+      # Removes the user from the permanent cookie store.
+      def forget(user)
+        user.forget
+        cookies.delete(user_id_cookie)
+        cookies.delete(user_token_cookie)
+      end
+
+    end
+
+  end
+end
+
+ActionView::Base.include Incline::Extensions::Session::Common
+ActionMailer::Base.include Incline::Extensions::Session::Common
+ActionController::Base.include Incline::Extensions::Session::Common
+ActionController::Base.include Incline::Extensions::Session::Controller
+ActionDispatch::IntegrationTest.include Incline::Extensions::Session::Common
+

data/lib/incline/extensions/string.rb

@@ -0,0 +1,50 @@
+module Incline::Extensions
+
+  ##
+  # Defines or overrides few string helper methods.
+  module String
+
+    ##
+    # Converts a hex string into a byte string.
+    #
+    # Whitespace in the string is ignored.
+    # The string must only contain characters valid for hex (ie - 0-9, A-F, a-f).
+    # The string must contain an even number of characters since each character only represents half a byte.
+    def to_byte_string
+      ret = self.gsub(/\s+/,'')
+      raise 'Hex string must have even number of characters.' unless ret.size % 2 == 0
+      raise 'Hex string must only contain 0-9 and A-F characters.' if ret =~ /[^0-9a-fA-F]/
+      [ret].pack('H*').force_encoding('ascii-8bit')
+    end
+
+    ##
+    # Converts a binary string into a hex string.
+    #
+    # The +grouping+ parameter can be set to true or an integer value specifying how many chars you want in
+    # each group.  If true or less than 1, then characters are put into groups of 2.
+    def to_hex_string(grouping = false)
+      ret = self.unpack('H*').first
+      if grouping
+        if grouping.is_a?(::Integer) && grouping > 0
+          ret.gsub(/(#{'.' * grouping})/,'\1 ').rstrip
+        else
+          ret.gsub(/(..)/,'\1 ').rstrip
+        end
+      else
+        ret
+      end
+    end
+
+    ##
+    # Converts a string into a boolean value.
+    #
+    # The following values are considered true: true, t, yes, y, on, 1
+    # Everything else will be false.
+    def to_bool
+      %w(true t yes y on 1).include?(self.downcase)
+    end
+
+  end
+end
+
+String.include Incline::Extensions::String