s2p 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdcd6755739bf7072a6271b5a28608c3c8c1261ad4dee98988219d7685ceba4a
-  data.tar.gz: 2c7a496e4dddd121faa9bc27910fa88c51219aa0eb785b589a58aed13d04347f
+  metadata.gz: f70e0e13983e0319e806abfb6a3233c9662974e1d4ed4aa5c3399639b52ed217
+  data.tar.gz: 8913f389f10b5cb25889e39ecb61134db36ccd578666137208228391e3c2bcd2
 SHA512:
-  metadata.gz: ad04853d770053e71d51bb97cb9d170ce9e25c270954d5bb7b91b85bfe3df8675e5760bc9f9d28eded3257aa588487fff81be465921057accdc2c216de09e8c7
-  data.tar.gz: f3c3de8c4be91fe9ba28a2ae70cafdfbaeabc0f434021e5b2033989335fbbfb816e2c544eeddef320ec7f5ab701895dadc3fe577fceb2a1721df021b0a6a6c65
+  metadata.gz: 9e487b0839f7d7dd5799b775013968b6b48bcc6c86a22443abe579cc33b3b13874f7f5b09d41214031031e1bd5cc6c22d7e3ac76cfc4468861c2fd2294dd6fed
+  data.tar.gz: 448b69b923d8e4df14c7c092c3e6773b4e86653871d47b4020688a74e9a244d5e0e22338f364344dc516e98dc4849ecfd6f7cd01f5b5f9de11f6ed2badac926b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Gregory Brown (skillstopractice.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/s2p/component.rb

@@ -58,4 +58,24 @@ module S2P
       end
     end
   end
+  
+  module ComponentDebugger
+    def to_html
+      if self.class.const_defined?(:DEBUG_TEMPLATE)
+        t(self.class::DEBUG_TEMPLATE, c: self, x: self.x)
+      else
+        t(DEBUG_TEMPLATE, c: self, x: self.x)
+      end
+    end
+    
+    DEBUG_TEMPLATE = <<-ERB
+      <div class="border border-solid p-3 border-danger">
+        <strong><pre><%= c.class %></pre></strong>
+        
+        <% if c.respond_to?(:debugging_info) %>
+          <pre><%= c.debugging_info.pretty_inspect %></pre>
+        <% end %>
+      </div>
+    ERB
+  end
 end

data/lib/s2p/search.rb

@@ -0,0 +1,210 @@
+module S2P
+  class Search
+    include ActiveModel::Validations
+
+    class << self
+      def setup(&conds)
+        @before_callback = conds
+      end
+
+      def scope
+        @before_callback.present? ? @before_callback[from] : from
+      end
+
+      def search_keys
+        [:page, :sort_order, :order_by] + conditions.keys + (@additional_search_params || [])
+      end
+
+      def additional_search_params(*keys)
+        @additional_search_params = keys
+      end
+
+      def create(params={})
+        new(params).tap(&:save)
+      end
+
+      def searches(from)
+        @from ||= from
+      end
+
+      def sortable_by(*names, table_name: self.from.table_name)
+        names.each do |name|
+          sortable_by!(name,
+            asc: ->(s) { s.reorder("#{table_name}.#{name} asc")  },
+            desc: ->(s) { s.reorder("#{table_name}.#{name} desc") }
+          )
+        end
+      end
+
+      def sortable_by_alias(sort_alias, sort_condition)
+        sortable_by!(sort_alias,
+          asc:  ->(s) { s.reorder("#{sort_condition} asc")  },
+          desc: ->(s) { s.reorder("#{sort_condition} desc") }
+        )
+      end
+
+      def sortable_by!(name, asc:, desc:)
+        name = name.to_sym
+
+        case asc
+        when String
+          sort_by_filters[name][:asc] = ->(s) { s.reorder(asc) }
+        when Proc
+          sort_by_filters[name][:asc] = asc
+        end
+
+        case desc
+        when String
+          sort_by_filters[name][:desc] = ->(s) { s.reorder(desc) }
+        when Proc
+          sort_by_filters[name][:desc] = desc
+        end
+      end
+
+      # FIXME: Consider introducing a SortFilter object of some sort?
+      def sort_by_filters
+        @sort_by_filters ||= Hash.new { |h,k| h[k] = {} }
+        @sort_by_filters[:id][:asc]  ||= ->(s) { s.reorder(id: :asc) }
+        @sort_by_filters[:id][:desc] ||= ->(s) { s.reorder(id: :desc) }
+
+        @sort_by_filters
+      end
+
+      def sort_by_default(key)
+        @sort_by_default_key = key
+      end
+
+      def sort_by_default_key
+        @sort_by_default_key || :id
+      end
+
+      def default_sort_order(params)
+        sort_order_defaults.update(params).symbolize_keys!
+      end
+
+      def sort_order_defaults
+        @sort_order_defaults ||=  Hash.new { |h,k| h[k] = :asc }
+      end
+
+      def cond(key, &scope)
+        conditions[key] = scope
+      end
+
+      def conditions
+        @conditions ||= {}
+      end
+
+      def cond_eq(*keys)
+        keys.each do |key|
+          cond_eq!(key, key)
+        end
+      end
+
+      def cond_eq!(key, column)
+        cond(key) { |s,v| s.where(column => v) }
+      end
+
+      def cond_start(*keys)
+        keys.each do |key|
+          cond_start!(key, "#{from.table_name}.#{key}")
+        end
+      end
+
+      def cond_start!(key, column)
+        cond(key) { |s,v| s.where("#{column} like ?", "#{v}%") }
+      end
+
+      def cond_like(*keys)
+        keys.each do |key|
+          cond_like!(key, "#{from.table_name}.#{key}")
+        end
+      end
+
+      def cond_like!(key, column)
+        cond(key) { |s,v| s.where("#{column} like ?", "%#{v}%") }
+      end
+
+      def cond_lt(*keys)
+        keys.each do |key|
+          cond(key) { |s,v| s.where("#{from.table_name}.#{key} < ?", v) }
+        end
+      end
+
+      def cond_lte(*keys)
+        keys.each do |key|
+          cond_lte!(key, "#{from.table_name}.#{key}")
+        end
+      end
+
+      def cond_lte!(key, column)
+        cond(key) { |s,v| s.where("#{column} <= ?", v) }
+      end
+
+      def cond_gte(*keys)
+        keys.each do |key|
+          cond_gte!(key, "#{from.table_name}.#{key}")
+        end
+      end
+
+      def cond_gte!(key, column)
+        cond(key) { |s,v| s.where("#{column} >= ?", v) }
+      end
+
+      def cond_gt(*keys)
+        keys.each do |key|
+          cond(key) { |s,v| s.where("#{from.table_name}.#{key} > ?", v) }
+        end
+      end
+
+      def cond_range(*ranges)
+        ranges.each do |start_key, end_key, column|
+          cond_range!(start_key, end_key, column)
+        end
+      end
+
+      def cond_range!(start_key, end_key, column)
+        cond_gte!(start_key, column)
+        cond_lte!(end_key, column)
+      end
+
+      def cond_cont(*keys)
+        keys.each do |key|
+          cond(key) { |s,v| s.where("#{from.table_name}.#{key} like ?", "%#{v}%") }
+        end
+      end
+
+      attr_reader :from
+    end
+
+    attr_reader :scopes, :results, :params, :conditions
+
+    def initialize(params={})
+      @params     = params.symbolize_keys
+      @conditions = self.class.conditions.select { |k,v| @params[k].present? }
+
+      @sort_by_key = @params.fetch(:order_by, self.class.sort_by_default_key).to_sym
+      @sort_order  = @params.fetch(:sort_order, self.class.sort_order_defaults[@sort_by_key]).to_sym
+
+      # FIXME: Should this be a validation instead?
+      setup(**params) if respond_to?(:setup)
+    end
+
+    def save
+      if valid?
+        @results = @conditions.inject(self.class.scope) { |relation, (key, scope)|
+          scope.call(relation, @params[key], @params)
+        }
+
+        @results = sorted(@results)
+      end
+    end
+
+    def sorted(relation)
+      self.class.sort_by_filters[@sort_by_key][@sort_order][relation]
+    end
+
+    def to_s
+      @params.select { |k,v| v.present? }.map { |k,v| "<strong>#{k.to_s.humanize}</strong>: #{v}" }.join(" + ")
+    end
+  end
+end

data/lib/s2p/version.rb

@@ -1,3 +1,3 @@
 module S2P
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: s2p
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Gregory Brown
 bindir: bin
 cert_chain: []
-date: 2025-02-02 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies: []
 description: Experimental dev utilies from skillstopractice.com. Will eventually find
   homes in their own gems if they pan out.
@@ -16,9 +16,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - lib/s2p/component.rb
 - lib/s2p/contractor.rb
 - lib/s2p/notebook.rb
+- lib/s2p/search.rb
 - lib/s2p/version.rb
 licenses:
 - MIT