yiffspace 0.1.7 → 0.2.0

data/lib/yiffspace/utils/open_hash.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require("active_support/hash_with_indifferent_access")
-
-module YiffSpace
-  module Utils
-    class OpenHash < ActiveSupport::HashWithIndifferentAccess
-      def initialize(constructor = nil, respond_to_missing: true)
-        super(constructor)
-        @respond_to_missing = respond_to_missing
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        return true if @respond_to_missing
-
-        name = name.to_s
-        key?(name) || name.end_with?("=") || super
-      end
-
-      def method_missing(name, *args)
-        if name.end_with?("=")
-          public_send(:[]=, name.to_s.chomp("=").to_sym, args.first)
-        elsif key?(name)
-          public_send(:[], name)
-        elsif @respond_to_missing
-          nil
-        else
-          super
-        end
-      end
-
-      def self.from(hash = nil, recursive: true, respond_to_missing: true, **kwargs)
-        hash = kwargs if hash.nil? && kwargs.any?
-        raise(ArgumentError, "no hash provided") if hash.nil?
-
-        oh = OpenHash.new(respond_to_missing: respond_to_missing)
-        hash.each do |key, value|
-          if recursive && value.is_a?(Hash)
-            oh[key] = OpenHash.from(value, recursive: recursive)
-          elsif recursive && value.is_a?(Array)
-            oh[key] = value.map { |v| v.is_a?(Hash) ? OpenHash.from(v, recursive: recursive, respond_to_missing: respond_to_missing) : v }
-          else
-            oh[key] = value
-          end
-        end
-        oh
-      end
-
-      def marshal_dump
-        [to_h, @respond_to_missing]
-      end
-
-      def marshal_load(data)
-        hash, @respond_to_missing = data
-        replace(hash)
-      end
-
-      def self.from_array(items, **)
-        items.map { |item| from(item, **) }
-      end
-    end
-  end
-end

data/lib/yiffspace/utils/parameter_builder.rb

@@ -1,121 +0,0 @@
-# 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

@@ -1,174 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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/set_env_constraint.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Utils
-    class SetEnvConstraint
-      attr_reader(:key, :value)
-
-      def initialize(key, value)
-        @key   = key.to_s
-        @value = value
-      end
-
-      def matches?(request)
-        request.env[key.to_s] = value
-      end
-    end
-  end
-end

data/lib/yiffspace/utils/table_builder.rb

@@ -1,169 +0,0 @@
-# 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?
-            view = block.binding.receiver
-            if view.respond_to?(:capture)
-              view.capture { block.call(item, row, column, self) }
-            else
-              block.call(item, row, column, self)
-            end
-          elsif attribute.is_a?(Symbol)
-            item.send(attribute)
-          else
-            ""
-          end
-        end
-      end
-
-      # Represents a custom row in the table body.
-      class Row
-        attr_reader(:block, :row_attributes)
-
-        def initialize(row_attributes = {}, &block)
-          @row_attributes = row_attributes
-          @block = block
-        end
-
-        def custom?
-          true
-        end
-
-        def value(index)
-          view = block.binding.receiver
-          if view.respond_to?(:capture)
-            view.capture { block.call(index, self) }
-          else
-            block.call(index, self)
-          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
-
-      def row(row_attributes = {}, &)
-        @items = @items.to_a unless @items.is_a?(Array)
-        @items << Row.new(row_attributes, &)
-      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 item.row_attributes if item.is_a?(Row)
-        return {} unless item.is_a?(YiffSpace.config.application_record_class)
-
-        {
-          id: "#{item.model_name.singular.dasherize}-#{item.id}",
-          **row_attributes,
-          **YiffSpace.config.application_controller_class.helpers.data_attributes_for(item),
-        }
-      end
-    end
-  end
-end

data/lib/yiffspace/utils/trace_logger.rb

@@ -1,91 +0,0 @@
-# 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