s2p 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c4d80aab71dba08ebb918defede00934913411cdc01c1b31ef573830b40df2b
-  data.tar.gz: 71208c5c082b9bd3f844ffc83ecbf9e289ff75e2a513705e46cd90681d67415d
+  metadata.gz: f98a35cf88d547dc89b457175c31b8a9932f18c44af388772992de27703b670c
+  data.tar.gz: 93f867ace5138682fbb13b16b189317ad71b4366298bf1bcd9ad581b613b8b8e
 SHA512:
-  metadata.gz: 04f9a3740e5feeec1acb7267d35fb55948da95675e57258b8982ae3ce569b11503af5c7e2e48ba8ea54e136f667ba6f74caad4a421e5d95ed37bd5739ce55903
-  data.tar.gz: 1370d721b7fa138c4f4d89004d1ea7549c16531331a1033659ed7d01eaa9dace93b98fdcda33b5a2088a9dbad1b7757ba08b23bc3e2463c322bbac2b45f35f1e
+  metadata.gz: 2421346b53220c10b4ad444cd3dc28dcc2efd1484f28468c0096640b94deaaeabab0f156d082fef3d6d02d47c9b800e8d04a45ed5fe797e3ac2be40a725f67e3
+  data.tar.gz: 6ca78934f8dfb0630e52262f38ed540214bda5767224b0f7a9f7b0b9e42f0e74780359e124257e2fcf21ce83cc45f824b9b82280c0666fa155ad16d67e5b6798

data/lib/s2p/notebook.rb

@@ -19,13 +19,32 @@ module S2P
     end
   end
 
+  class Notebook
+    class Component
+      def self.[](*a, **o)
+        new(*a, **o)
+      end
+    end
+  end
+
   class NotebookRunner < Redcarpet::Render::HTML
+    def codespan(code)
+      case code
+      when /^~ /
+        eval(code[/^~ (.*)/, 1], MAIN_BINDING)
+      else
+        eval("puts(#{code})", MAIN_BINDING)
+      end
+
+      ""
+    end
+
     def block_code(text, operation)
       case operation
-      when "ruby"
+      when nil, "ruby"
         eval(text, MAIN_BINDING) # See end of file for this hack.
-      else
-        raise NotImplementedError
+      when "text"
+        puts(text)
       end
 
       ""

data/lib/s2p/search.rb

@@ -0,0 +1,225 @@
+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
+
+      def cond_localized_date_range(*ranges)
+        ranges.each do |range|
+          cond_localized_date_range!(*range)
+        end
+      end
+
+      # NOTE: You can use cond_range instead of this method when working with date columns
+      # in the DB as they're zoneless. This method is only necessary when working with
+      # datetime fields, because for those you will need to translate the beginning/end of the
+      # range to the localized beginning/end of day times.
+      def cond_localized_date_range!(start_key, end_key, column)
+        cond(start_key) { |s,v| s.where("#{from.table_name}.#{column} >= ?", PetersenToolbox.to_local_time(Date.parse(v)).beginning_of_day) }
+        cond(end_key) { |s,v| s.where("#{from.table_name}.#{column} <= ?", PetersenToolbox.to_local_time(Date.parse(v)).end_of_day) }
+      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.4"
+  VERSION = "0.0.6"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: s2p
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Gregory Brown
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-02 00:00:00.000000000 Z
+date: 2025-02-08 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.
@@ -19,10 +20,13 @@ files:
 - lib/s2p/component.rb
 - lib/s2p/contractor.rb
 - lib/s2p/notebook.rb
+- lib/s2p/search.rb
 - lib/s2p/version.rb
+homepage:
 licenses:
 - MIT
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -37,7 +41,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Experimental dev utilies from skillstopractice.com
 test_files: []