tidied 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 463235ca364942725d0325e85cce2fe4ae40e59a7c84f80f4020e551f1062624
-  data.tar.gz: c50531367cbd402a7a778b7bf6db04494b6d6282bb83c54ed803e7a4e8d1ce3c
+  metadata.gz: 6f28badb45e6138ff37f9aa60a877fd335a217f8b2feda6e0a3c323a317f3812
+  data.tar.gz: 77d1682eb7ea5c1d52512d6dfdfa78e97c10b9aad076657ae3ccfc3e75c8b999
 SHA512:
-  metadata.gz: 585c8693f33827610835cbe7b95abcdf37bf0339f484290d1e8f6fca662963715aba3a2a08098fbb6dd5e77e5d8f51b2363a9c97ace869a448dacaade24ce1ae
-  data.tar.gz: 6b9bf48cc6684674b36bce655ed1b08c2ad9008dfe0a3b624ecb3102e660678e2ab5f1795076ab23985c652cb8d4e9bd11df96f588af4594a90003dd82a9d2d7
+  metadata.gz: 9d1525ca8780bd9692f7e7c6e22f5f6154cf949ece328db960d52b47ffc8fe85d5d4b5c51f25f14d4ed0b3266d186a330beaece8581d6e8fd19fea56c26a6582
+  data.tar.gz: 7ce14f95efbc480cc073ab4be43c9a4c25ad0aaae0075e876e7d7efeb64fd8f48d5a3294dabc31b6fea5618708841aaccb66a2958a7b02b271cc163d2584d6c4

data/Gemfile.lock

@@ -2,10 +2,13 @@ PATH
   remote: .
   specs:
     tidied (0.1.0)
+      anyway_config (>= 2.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    anyway_config (2.1.0)
+      ruby-next-core (>= 0.11.0)
     ast (2.4.1)
     diff-lcs (1.4.4)
     parallel (1.20.1)
@@ -39,6 +42,7 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.4.0)
       parser (>= 2.7.1.5)
+    ruby-next-core (0.12.0)
     ruby-progressbar (1.11.0)
     unicode-display_width (2.0.0)
 

data/lib/tidied.rb

@@ -1,8 +1,38 @@
 # frozen_string_literal: true
 
 require_relative "tidied/version"
+require_relative "tidied/config"
+require "forwardable"
+require_relative "tidied/sorting"
+require_relative "tidied/filtering"
+
+class Tidied
+  extend Forwardable
+  def_delegators :@view, :first_name, :last_name
 
-module Tidied
   class Error < StandardError; end
-  # Your code goes here...
+
+  class << self
+    def config
+      @config ||= Config.new
+      yield @config if block_given?
+      @config
+    end
+
+    def configure
+      yield(config) if block_given?
+    end
+  end
+
+  def initialize(collection)
+    @collection = collection
+  end
+
+  def sort(*instructions)
+    Sorting.new(*instructions).execute(@view)
+  end
+
+  def filter(*instructions)
+    Filtering.new(*instructions).execute(@view)
+  end
 end

data/lib/tidied/filtering.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "date"
+
+class Tidied
+  class Filtering
+    def initialize(*instructions)
+      @defaults = {
+        operator: :==,
+        accessor: :itself,
+        value: nil,
+        case_sensitive: true
+      }
+      @instructions = instructions.map do |instruction|
+        @defaults.merge(instruction)
+      end
+    end
+
+    def execute(collection)
+      return false unless collection.respond_to? :select
+
+      @instructions.reduce(collection) do |output, instruction|
+        output.select do |item|
+          raw_value             =   access_value(from: item, at: instruction[:accessor])
+          attribute_value       =   process_value(from: raw_value, given: instruction)
+
+          next false if not attribute_value.respond_to?(instruction[:operator])
+
+          operator_method       =   attribute_value.method(instruction[:operator])
+          query_value           =   process_value(from: instruction[:value], given: instruction)
+
+          if operator_method.arity.zero?
+            operator_method.call
+          elsif operator_method.arity == 1
+            operator_method.call(query_value)
+          elsif operator_method.arity.abs.positive?
+            operator_method.call(*query_value)
+          else
+            raise Error.new("invalid operator `#{instruction[:operator]}` for `#{attribute_value}` at `#{instruction[:accessor]}`")
+          end
+        end
+      end
+    end
+
+    private
+
+    def access_value(from:, at:)
+      path = at.to_s.split('.')
+      path.reduce(from) do |object, signal|
+        break nil unless object.respond_to? signal
+
+        object.public_send(signal)
+      end
+    end
+
+    def process_value(from:, given:)
+      return from.map { |v| process_value(from: v, given: given) } if from.respond_to?(:each)
+      return from                     if not from.is_a?(String) || from.is_a?(Symbol)
+      return from.downcase            if not given[:case_sensitive]
+
+      from
+    end
+  end
+end

data/lib/tidied/sorting.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "date"
+
+class Tidied
+  class Sorting
+    def initialize(*instructions)
+      @defaults = {
+        direction: :ascending,
+        nils: :small,
+        accessor: :itself,
+        case_sensitive: true,
+        normalized: false,
+        natural: false
+      }
+      @instructions = instructions.map do |instruction|
+        @defaults.merge(instruction)
+      end
+    end
+
+    def execute(collection)
+      collection.sort_by do |item|
+        @instructions.map do |instruction|
+          raw_value             =   access_value(from: item, at: instruction[:accessor])
+          processed_value       =   process_value(from: raw_value, given: instruction)
+          numeric_value         =   numeric_value(from: processed_value)
+          direction_multiplier  =   direction_multiplier(given: instruction[:direction])
+          nils_multiplier       =   nils_multiplier(given: instruction[:nils])
+
+          # p({ raw_value: raw_value, processed_value: processed_value, numeric_value: numeric_value, direction_multiplier: direction_multiplier, nils_multiplier: nils_multiplier })
+
+          if numeric_value.nil?                           # [1, 0] [-1, 0]
+            [direction_multiplier * nils_multiplier, 0]
+          else                                            # [0, n] [0, -n]
+            [0, numeric_value * direction_multiplier]
+          end                                             # [-1, 0] [0, -n] [0, n] [1, 0]
+        end
+      end
+    end
+
+    private
+
+    def access_value(from:, at:)
+      path = at.to_s.split('.')
+      path.reduce(from) do |object, signal|
+        break nil unless object.respond_to? signal
+
+        object.public_send(signal)
+      end
+    end
+
+    def process_value(from:, given:)
+      return from                     if not from.is_a?(String) || from.is_a?(Symbol)
+      return from.downcase            if not given[:case_sensitive]
+      return normalize(from) + from   if given[:normalized]
+      return segment(from)            if given[:natural]
+
+      from
+    end
+
+    def numeric_value(from:)
+      return from   if from.is_a?(Numeric)
+      return 1      if from == true
+      return 0      if from == false
+
+      if from.is_a?(String) || from.is_a?(Symbol)
+        string_to_numeric_value(from)
+      elsif from.is_a?(Date)
+        time_to_numeric_value(Time.new(from.year, from.month, from.day, 00, 00, 00, 00))
+      elsif from.respond_to?(:to_time)
+        time_to_numeric_value(from.to_time)
+      elsif from.respond_to?(:map)
+        segment_array_to_numeric_value(from)
+      else
+        from
+      end
+    end
+
+    def direction_multiplier(given:)
+      return -1 if given == :descending
+
+      1
+    end
+
+    def nils_multiplier(given:)
+      return -1 if given == :small
+
+      1
+    end
+
+    def string_to_numeric_value(string)
+      string                                          # "aB09ü""
+        .chars                                        # ["a", "B", "0", "9", "ü"]
+        .map { |char| char.ord.to_s.rjust(3, '0') }   # ["097", "066", "048", "057", "252"]
+        .insert(1, '.')                               # ["097", ".", "066", "048", "057", "252"]
+        .reduce(&:concat)                             # "097.066048057252"
+        .to_r                                         # (24266512014313/2500000000000)
+    end
+
+    def time_to_numeric_value(time) # https://stackoverflow.com/a/30604935/2884386
+      time                                            # 2000-01-01 00:00:00 +0000
+        .utc                                          # 2000-01-01 00:00:00 UTC
+        .to_f                                         # 946684800.0
+        .*(1000)                                      # 946684800000.0
+        .round                                        # 946684800000
+    end
+
+    def segment_array_to_numeric_value(segments)
+      segments                                        # ["a", 12, "b", 34, "c"]
+        .map { |x| x.is_a?(Numeric) ? x : x.ord }     # [97, 12, 98, 34, 99]
+        .map { |n| (n + 1).to_s.rjust(3, '0') }       # ["098", "013", "099", "035", "100"]
+        .insert(1, '.')                               # ["098", ".", "013", "099", "035", "100"]
+        .join                                         # "098.013099035100"
+        .to_r                                         # (980130990351/100000000000)
+    end
+
+    def normalize(string) # https://github.com/grosser/sort_alphabetical
+      string                                          # "Äaáäßs"
+        .unicode_normalize(:nfd)                      # "Äaáäßs"
+        .downcase(:fold)                              # "äaáässs"
+        .chars                                        # ["a", "̈", "a", "a", "́", "a", "̈", "s", "s", "s"]
+        .select { |char| char =~ /[[:ascii:]]/ }      # ["a", "a", "a", "a", "s", "s", "s"]
+        .join                                         # "aaaasss"
+    end
+
+    def segment(string) # https://stackoverflow.com/a/15170063/2884386
+      digits_or_not_digit_regex = /[[:digit:]]+|[^[:digit:]]/
+
+      string                                          # "ab12cd34,-56"
+        .scan(digits_or_not_digit_regex)             # ["a", "b", "12", "c", "d", "34", ",", "-", "56"]
+        .map { |a| a =~ /[[:digit:]]+/ ? a.to_i : a } # ["a", "b", 12, "c", "d", 34, ",", "-", 56]
+    end
+  end
+end

data/lib/tidied/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Tidied
-  VERSION = "0.0.1"
+class Tidied
+  VERSION = "0.1.0"
 end

data/tidied.gemspec

@@ -28,8 +28,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "anyway_config", ">= 2.0.0"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tidied
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - fractaledmind
@@ -9,7 +9,21 @@ autorequire:
 bindir: exe
 cert_chain: []
 date: 2021-01-20 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 description: Filter, sort, and/or paginate your data, whether it comes from a database
   or is a simple Ruby collection.
 email:
@@ -30,6 +44,8 @@ files:
 - bin/console
 - bin/setup
 - lib/tidied.rb
+- lib/tidied/filtering.rb
+- lib/tidied/sorting.rb
 - lib/tidied/version.rb
 - tidied.gemspec
 homepage: https://github.com/fractaledmind/tidied