yiffspace 0.0.1 → 0.0.3

data/lib/yiffspace/utils/parameter_builder.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    class ParameterBuilder
+      def self.serial_parameters(only_string, object, options = {})
+        only_array = split_only_string(only_string)
+        get_only_hash(only_array, object, options)
+      end
+
+      def self.get_only_hash(only_array, object, options = {}, seen_objects = [])
+        return {} if object.nil?
+
+        is_root = seen_objects.empty?
+        only_hash = { only: [], include: [], methods: [] }
+        available_includes = object.available_includes
+        attributes, methods = object.api_attributes(options[:user]).partition { |attr| object.has_attribute?(attr) }
+        methods -= available_includes
+        # Attributes and/or methods may be included in the final pass, but not includes
+        seen_objects << object.class.name
+        underscore = false
+        only_array.each do |item|
+          if item == "_"
+            underscore = true
+            next
+          end
+          match = item.match(/(\w+)\[(.+?)\]$/)
+          item = (match || [])[1] || item
+          item_sym = item.to_sym
+          was_seen = inclusion_seen?(item, object.class, seen_objects)
+          if match && available_includes.include?(item_sym) && (!was_seen || is_root)
+            item_object = object.send(item_sym)
+            next if item_object.nil?
+
+            item_object = item_object[0] if item_object.is_a?(ActiveRecord::Relation)
+            item_array = split_only_string(match[2])
+            item_hash = get_only_hash(item_array, item_object, options, seen_objects.clone)
+            only_hash[:include] << { item_sym => item_hash }
+          elsif available_includes.include?(item_sym) && (!was_seen || is_root)
+            only_hash[:include] << item_sym
+          elsif attributes.include?(item_sym)
+            only_hash[:only] << item_sym
+          elsif methods.include?(item_sym)
+            only_hash[:methods] << item_sym
+            only_hash[:only] << item_sym
+          end
+        end
+        only_hash.delete(:include) if only_hash[:include].empty?
+        only_hash.delete(:methods) if only_hash[:methods].empty?
+        only_hash[:only].unshift("_") if underscore
+        only_hash
+      end
+
+      def self.includes_parameters(only_string, model_name)
+        return [] if only_string.blank?
+
+        only_array = split_only_string(only_string)
+        get_includes_array(only_array, model_name)
+      end
+
+      def self.get_includes_array(only_array, model_name, seen_objects = [])
+        is_root = seen_objects.empty?
+        include_array = []
+        model = Kernel.const_get(model_name)
+        available_includes = model.available_includes
+        # Attributes and/or methods may be included in the final pass, but not includes
+        seen_objects << model_name
+        only_array.each do |item|
+          match = item.match(/(\w+)\[(.+?)\]$/)
+          item = (match || [])[1] || item
+          item_sym = item.to_sym
+          was_seen = inclusion_seen?(item, model, seen_objects)
+          if match && available_includes.include?(item_sym) && (!was_seen || is_root)
+            item_array = split_only_string(match[2])
+            model.associated_models(item).each do |m|
+              item_array = get_includes_array(item_array, m, seen_objects.clone)
+              include_array << (item_array.empty? ? item_sym : { item_sym => item_array })
+            end
+          elsif available_includes.include?(item_sym) && (!was_seen || is_root)
+            include_array << item_sym
+          end
+        end
+        include_array
+      end
+
+      def self.inclusion_seen?(inclusion, class_object, seen_objects)
+        if class_object.reflections[inclusion]
+          inclusion_class = class_object.reflections[inclusion].class_name
+          max_seen = (class_object.multiple_includes.include?(inclusion.to_sym) ? 1 : 0)
+          seen_objects.count(inclusion_class) > max_seen
+        else
+          false
+        end
+      end
+
+      def self.split_only_string(only_string)
+        only_array = []
+        offset = 0
+        position = 0
+        level = 0
+        loop do
+          str = only_string[Range.new(position, -1)]
+          match = str.match(/[,\[\]]/)
+          break unless match
+
+          start_pos, end_pos = match.offset(0)
+          if match[0] == "," && level.zero?
+            only_array << only_string[Range.new(offset, position + start_pos - 1)]
+            offset = position + end_pos
+          elsif match[0] == "["
+            level += 1
+          elsif match[0] == "]"
+            level -= 1
+          end
+          position += end_pos
+        end
+        only_array << only_string[Range.new(offset, -1)]
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/parse_value.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module ParseValue
+      MAX_INT = 2_147_483_647
+      MIN_INT = -2_147_483_648
+      extend(self)
+
+      def date_range(target)
+        case target
+          # 10_yesterweeks_ago, 10yesterweekago
+        when /\A(\d{1,2})_?yester(week|month|year)s?_?ago\z/
+          yester_range($1.to_i, $2)
+        when /\Ayester(week|month|year)\z/
+          yester_range(1, $1)
+        when /\A(day|week|month|year)\z/
+          [:gte, Time.zone.now - 1.send($1)]
+          # 10_weeks_ago, 10w
+        when /\A(\d+)_?(s(econds?)?|mi(nutes?)?|h(ours?)?|d(ays?)?|w(eeks?)?|mo(nths?)?|y(ears?)?)_?(ago)?\z/i
+          [:gte, time_string(target)]
+        else
+          range(target, :date)
+        end
+      end
+
+      def range_fudged(range, type)
+        result = range(range, type)
+        if result[0] == :eq
+          new_min = [(result[1] * 0.95).to_i, MIN_INT].max
+          new_max = [(result[1] * 1.05).to_i, MAX_INT].min
+          [:between, new_min, new_max]
+        else
+          result
+        end
+      end
+
+      def range(range, type = :integer)
+        if range.start_with?("<=")
+          [:lte, cast(range.delete_prefix("<="), type)]
+
+        elsif range.start_with?("..")
+          [:lte, cast(range.delete_prefix(".."), type)]
+
+        elsif range.start_with?("<")
+          [:lt, cast(range.delete_prefix("<"), type)]
+
+        elsif range.start_with?(">=")
+          [:gte, cast(range.delete_prefix(">="), type)]
+
+        elsif range.end_with?("..")
+          [:gte, cast(range.delete_suffix(".."), type)]
+
+        elsif range.start_with?(">")
+          [:gt, cast(range.delete_prefix(">"), type)]
+
+        elsif range.include?("..")
+          left, right = range.split("..", 2)
+          [:between, cast(left, type), cast(right, type)]
+
+        elsif range.include?(",")
+          [:in, range.split(",").first(YiffSpace.config.max_multi_count.call).map { |x| cast(x, type) }]
+
+        else
+          [:eq, cast(range, type)]
+
+        end
+      end
+
+      RANGE_INVERSIONS = {
+        lte: :gte,
+        lt:  :gt,
+        gte: :lte,
+        gt:  :lt,
+      }.freeze
+
+      def invert_range(range)
+        # >10 <=> <10
+        range[0] = RANGE_INVERSIONS[range[0]] || range[0]
+        # 10..20 <=> 20..10
+        range[1], range[2] = range[2], range[1] if range[0] == :between
+        range
+      end
+
+      private
+
+      def cast(object, type)
+        case type
+        when :integer
+          object.to_i.clamp(MIN_INT, MAX_INT)
+
+        when :float
+          # Floats obviously have a different range but this is good enough
+          object.to_f.clamp(MIN_INT, MAX_INT)
+
+        when :date, :datetime
+          case object
+          when "today"
+            return Date.current
+          when "yesterday"
+            return Date.yesterday
+          when "decade"
+            return Date.current - 10.years
+          when /\A(day|week|month|year)\z/
+            return Date.current - 1.send($1.to_sym)
+          end
+
+          ago = time_string(object)
+          return ago if ago.present?
+
+          begin
+            Time.zone.parse(object)
+          rescue ArgumentError
+            nil
+          end
+
+        when :age
+          time_string(object)
+
+        when :ratio
+          left, right = object.split(":", 10)
+
+          if right && right.to_f != 0.0
+            (left.to_f / right.to_f).round(10)
+          elsif right
+            0.0
+          else
+            object.to_f.round(2)
+          end
+
+        when :filesize
+          size = object.downcase
+          if size.end_with?("kb")
+            size.to_f.kilobytes
+          elsif size.end_with?("mb")
+            size.to_f.megabytes
+          else
+            size.to_f
+          end.to_i
+        end
+      end
+
+      def yester_range(count, unit)
+        origin = Date.current - count.send(unit)
+        start = origin.send("beginning_of_#{unit}")
+        stop = origin.send("end_of_#{unit}")
+        [:between, start, stop]
+      end
+
+      def time_string(target)
+        target =~ /\A(\d+)_?(s(econds?)?|mi(nutes?)?|h(ours?)?|d(ays?)?|w(eeks?)?|mo(nths?)?|y(ears?)?)_?(ago)?\z/i
+
+        size = $1.to_i
+        unit = $2&.downcase || ""
+
+        if unit.start_with?("s")
+          size.seconds.ago
+        elsif unit.start_with?("mi")
+          size.minutes.ago
+        elsif unit.start_with?("h")
+          size.hours.ago
+        elsif unit.start_with?("d")
+          size.days.ago
+        elsif unit.start_with?("w")
+          size.weeks.ago
+        elsif unit.start_with?("mo")
+          size.months.ago
+        elsif unit.start_with?("y")
+          size.years.ago
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/routes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    # Allow Rails URL helpers to be used outside of views.
+    #
+    # @example
+    #   Routes.posts_path(tags: "male")
+    #   => "/posts?tags=male"
+    #
+    # @see config/routes.rb
+    # @see https://guides.rubyonrails.org/routing.html
+    module Routes
+      module_function
+
+      def method_missing(name, *, &)
+        url_helpers = Rails.application.routes.url_helpers
+        return url_helpers.public_send(name, *, &) if url_helpers.respond_to?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        Rails.application.routes.url_helpers.respond_to?(name, include_private) || super
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/table_builder.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    # A helper class for building HTML tables. Used in views.
+    #
+    # @example
+    #   <%= table_for @tags do |table| %>
+    #     <% table.column :name do |tag| %>
+    #       <%= link_to_wiki "?", tag.name  %>
+    #       <%= link_to tag.name, posts_path(tags: tag.name) %>
+    #     <% end %>
+    #     <% table.column :post_count %>
+    #   <% end %>
+    #
+    # @see app/views/table_builder/_table.html.erb
+    class TableBuilder
+      # Represents a single column in the table.
+      class Column
+        attr_reader(:attribute, :name, :block, :header_attributes, :body_attributes, :caption)
+
+        # Define a table column.
+        #
+        # @example
+        #   <% table.column :post_count %>
+        #
+        # @example
+        #   <% table.column :name do |tag| %>
+        #     <%= tag.pretty_name %>
+        #   <% end %>
+        #
+        # @param attribute [Symbol] The attribute in the model the column is for.
+        #   The column's name and value will come from this attribute by default.
+        # @param name [String] the column's name, if different from the attribute name.
+        # @param column [String] the column name
+        # @param th [Hash] the HTML attributes for the column's <th> tag.
+        # @param td [Hash] the HTML attributes for the column's <td> tag.
+        # @param width [String] the HTML width value for the <th> tag.
+        # @yieldparam item a block that returns the column value based on the item.
+        def initialize(attribute = nil, column: nil, th: {}, td: {}, width: nil, name: nil, &block)
+          @attribute = attribute
+          @column = column
+          @header_attributes = { width: width, **th }
+          @body_attributes = td
+          @block = block
+
+          @name = name || attribute
+          @name = @name.to_s.titleize unless @name.is_a?(String)
+
+          return unless @name.present? || @column.present?
+
+          if @column.present?
+            column_class = "#{@column}-column"
+          else
+            column_class = "#{@name.parameterize.dasherize}-column"
+          end
+          @header_attributes[:class] = "#{column_class} #{@header_attributes[:class]}".strip
+          @body_attributes[:class] = "#{column_class} #{@body_attributes[:class]}".strip
+        end
+
+        # Returns the value of the table cell.
+        # @param item [ApplicationRecord] the table cell item
+        # @param row [Integer] the table row number
+        # @param column [Integer] the table column number
+        # @return [#to_s] the value of the table cell
+        def value(item, row, column)
+          if block.present?
+            block.call(item, row, column, self)
+            nil
+          elsif attribute.is_a?(Symbol)
+            item.send(attribute)
+          else
+            ""
+          end
+        end
+      end
+
+      attr_reader(:columns, :table_attributes, :row_attributes, :items)
+
+      # Build a table for an array of objects, one object per row.
+      #
+      # The <table> tag is automatically given an HTML id of the form `{name}-table`.
+      # For example, `posts-table`, `tags-table`.
+      #
+      # The <tr> tag is automatically given an HTML id of the form `{name}-{id}`.
+      # For example, `post-1234`, `tag-4567`, etc. Each <tr> tag also gets a set of
+      # data attributes for each model; see #html_data_attributes in app/policies.
+      #
+      # @param items [Array<ApplicationRecord>] The list of ActiveRecord objects to
+      #   build the table for. One item per table row.
+      # @param tr [Hash] optional HTML attributes for the <tr> tag for each row
+      # @param table_attributes [Hash] optional HTML attributes for the <table> tag
+      # @yieldparam table [self] the table being built
+      def initialize(items, tr: {}, **table_attributes)
+        @items = items
+        @columns = []
+        @table_attributes = { class: "striped", **table_attributes }
+        @row_attributes = tr
+
+        @table_attributes[:id] ||= "#{items.model_name.plural.dasherize}-table" if items.respond_to?(:model_name)
+
+        yield(self) if block_given?
+      end
+
+      # Set the table caption
+      def caption
+        @caption = yield if block_given?
+        @caption
+      end
+
+      # Add a column to the table.
+      # @example
+      #   table.column(:name)
+      def column(*, **options, &)
+        opt = options.extract!(:if, :unless)
+        return if (opt.key?(:if) && !opt[:if]) || (opt.key?(:unless) && opt[:unless])
+
+        @columns << Column.new(*, **options, &)
+      end
+
+      # Return the HTML attributes for each <tr> tag.
+      # @param item [ApplicationRecord] the item for this row
+      # @param _row [Integer] the row number (unused)
+      # @return [Hash] the <tr> attributes
+      def all_row_attributes(item, _row)
+        return {} unless item.is_a?(ApplicationRecord)
+
+        {
+          id: "#{item.model_name.singular.dasherize}-#{item.id}",
+          **row_attributes,
+          **ApplicationController.helpers.data_attributes_for(item),
+        }
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/trace_logger.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module TraceLogger
+      module_function
+
+      COLORS = {
+        black:   "\e[30m",
+        red:     "\e[31m",
+        green:   "\e[32m",
+        yellow:  "\e[33m",
+        blue:    "\e[34m",
+        magenta: "\e[35m",
+        cyan:    "\e[36m",
+        white:   "\e[37m",
+        reset:   "\e[0m",
+      }.freeze
+
+      # noinspection RubyLiteralArrayInspection
+      LEVELS = {
+        debug:   ["%<cyan>s", "%<blue>s"],
+        error:   ["%<red>s", "%<red>s"],
+        info:    ["%<cyan>s", "%<blue>s"],
+        warn:    ["%<yellow>s", "%<yellow>s"],
+        default: ["%<white>s", "%<white>s"],
+      }.freeze
+
+      def format_level(level)
+        level = level.to_sym
+        primary, alternate = LEVELS.fetch(level, LEVELS[:default])
+        colorize("#{alternate}[%<reset>s#{primary}#{level.to_s.upcase}%<reset>s#{alternate}]%<reset>s")
+      end
+
+      def colorize(text, **)
+        format(text, **COLORS, **)
+      end
+
+      def debug(*, **)
+        _log(*, level: :debug, **)
+      end
+
+      def error(*, **)
+        _log(*, level: :error, **)
+      end
+
+      def info(*, **)
+        _log(*, level: :info, **)
+      end
+
+      def warn(*, **)
+        _log(*, level: :warn, **)
+      end
+
+      def _log(*arg, ignore: nil, level: :log, lines: 3, format: nil)
+        return unless Rails.logger.public_send("#{level}?")
+
+        if arg.one?
+          name = nil
+          message = arg.first
+        else
+          name = arg.shift
+          message = arg.join
+        end
+        primary, alternate = LEVELS.fetch(level, LEVELS[:default])
+        args = { level: format_level(level), name: name, message: message }
+        fmt = "%<level>s"
+        if format.nil?
+          if name.present?
+            fmt += " #{alternate}[%<reset>s%<magenta>s%<name>s%<reset>s#{alternate}]%<reset>s " \
+                   "#{primary}%<message>s%<reset>s"
+          else
+            fmt += " #{primary}%<message>s%<reset>s"
+          end
+        else
+          fmt += " #{format}%<reset>s"
+        end
+        ignore = Array(ignore).unshift(%r{/yiffspace/utils/trace_logger\.rb})
+        callers = caller_locations.reject do |loc|
+          path = loc.absolute_path || loc.path
+          !Rails.backtrace_cleaner.clean_frame("#{path}:#{loc.lineno}") || ignore.any? { |i| path.match?(i) }
+        end
+        callers = callers.take(lines) if lines.present?
+        Rails.logger.public_send(level, colorize(fmt, **args))
+        callers.each { |c| Rails.logger.public_send(level, "↳ #{c.path.gsub(%r{^/app/}, '')}:#{c.lineno} in `#{c.label}`") }
+      end
+
+      private_class_method(:_log)
+    end
+  end
+end