shoperb_liquid 0.0.1

data/lib/shoperb_liquid/filters/collection_filters.rb

@@ -0,0 +1,26 @@
+module ShoperbLiquid
+  module CollectionFilters
+
+    def with_custom_field(input, name, value, leave_blank=true)
+      ary = Liquid::StandardFilters::InputIterator.new(input, context)
+
+      ary.select do |el|
+        hash_value = el.custom_fields[name]
+        if hash_value
+          if hash_value["set_values"] == []
+            leave_blank
+          elsif !value || value == ""
+            false
+          else
+            hash_value["set_values"].include?(value)
+          end
+        else
+          # if true and not present, then leacing in collection
+          leave_blank
+        end
+      end
+      # filter_array(input, property, target_value) { |ary, &block| ary.select(&block) }
+    end
+
+  end
+end

data/lib/shoperb_liquid/filters/datum_filters.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  #
+  # Helpers for working with strings,
+  # numbers, money, dates, weight units
+  #
+  module DatumFilters
+    include ActionView::Helpers::NumberHelper
+    include ActionView::Helpers::OutputSafetyHelper
+
+    # either with symbol or code
+    def money(money)
+      _money(money, precision: money_precision(money))
+    end
+
+    def money_with_cents(money)
+      _money(money, precision: 2)
+    end
+
+    # with both symbol and code
+    def money_with_currency(money)
+      "#{_money(money, precision: 2)} #{shop.currency.code}"
+    end
+
+    def money_precision(money)
+      fmt = "%05.2f" % money.to_f
+      _, cost_cents = fmt.split "."
+
+      cost_cents.to_i == 0 ? 0 : 2
+    end
+
+    # just numbers
+    def money_without_currency(money)
+      number_to_currency(money, unit: "", delimiter: " ")
+    end
+
+    def without_cents(money)
+      money.to_i
+    end
+
+    def num_with_2_meaning_nums(money)
+      "%05.2f" % money
+    end
+
+    def weight_with_unit(weight, precision=nil)
+      return if weight.nil?
+
+      weight = "%.#{precision}f" % weight if precision
+
+      "#{weight} #{shop.metric? ? "kg" : "lbs"}" # TODO
+    end
+
+    def dimension_with_unit(size)
+      "#{size} #{shop.metric? ? "cm" : "inch"}" # TODO
+    end
+
+    def upcase(value)
+      value.to_s.upcase
+    end
+
+    def downcase(value)
+      value.to_s.downcase
+    end
+
+    def titleize(value)
+      value.to_s.titlecase
+    end
+
+    def size(value)
+      value.size rescue value.to_s.size
+    end
+
+    def date(value, formatting)
+      return unless value
+
+      value = Time.at(value) if value.is_a?(Integer)
+      value = Time.now if value.eql?("now")
+      date  = value.kind_of?(String) ? Date.parse(value) : value
+      I18n.l(date, format: formatting)
+    end
+
+    def pluck(value, key)
+      value.pluck(key)
+    end
+
+    def json(value)
+      value.to_json if value.is_a?(CollectionDrop)
+    end
+
+    def debug(object)
+      safe_join(["<pre>".html_safe, object.inspect, "</pre>".html_safe], "\n")
+    end
+
+    def numeric(value)
+      value.to_i
+    end
+
+    def plus(value, add)
+      value.to_i + add
+    end
+
+    def minus(value, remove)
+      value.to_i - remove
+    end
+
+    def decimal_plus(value, add)
+      value.to_d + add.to_d
+    end
+
+    def decimal_minus(value, remove)
+      value.to_d - remove.to_d
+    end
+
+    # we use default times filter
+    # def times(value, times)
+    #   value.to_i * times.to_i
+    # end
+
+    def decimal_times(value, times)
+      value.to_d * times.to_d
+    end
+
+    def random(value, limit=nil)
+      return value unless limit
+      value.to_a.sample limit
+    end
+    deprecate :random, deprecator: ::ActiveSupport::Deprecation
+
+    def sum(collection, field)
+      collection.pluck(field).sum
+    end
+
+    protected
+
+    def shop
+      @context["shop"]
+    end
+
+    private
+
+    def _money(money, **args)
+      if shop.currency.symbol
+        number_to_currency(money, unit: shop.currency.symbol, format: "%u%n", delimiter: " ", **args)
+      else
+        number_to_currency(money, unit: shop.currency.code, format: "%n %u", delimiter: " ", **args)
+      end
+    end
+  end
+end

data/lib/shoperb_liquid/filters/extension_filters.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  #
+  # Translating of strings in the theme
+  #
+  module ExtensionFilters
+    def sort(input, property = nil)
+      if input.is_a?(Hash)
+        # replacing values
+        property = 0 if property == "key"
+        property = 1 if property == "value"
+        
+        ret = if property
+          input.sort{|a,b| nil_safe_compare(a[property],b[property])}.to_h
+        else
+          input.sort{|a,b| nil_safe_compare(a,b)}.to_h
+        end
+        return ret
+      end
+      super
+    end
+    
+    def nil_safe_compare(a, b)
+      a = a.to_s if a.is_a?(Array)
+      b = b.inspect if b.is_a?(Array)
+      if !a.nil? && !b.nil?
+        a <=> b
+      else
+        a.nil? ? 1 : -1
+      end
+    end
+
+  end
+end

data/lib/shoperb_liquid/filters/html_filters.rb

@@ -0,0 +1,46 @@
+module ShoperbLiquid
+  module HtmlFilters
+    def modulo_word(word, index, modulo)
+      index.to_i % modulo == 0 ? word : ""
+    end
+
+    def default_pagination(paginate, *args)
+      return "" if paginate["parts"].empty?
+
+      previous_label = ShoperbLiquid.config.translator.translate("navigation.previous")
+      next_label     = ShoperbLiquid.config.translator.translate("navigation.next")
+
+      previous_link = link("previous", previous_label, paginate)
+      next_link     = link("next", next_label, paginate)
+
+      links = ""
+      paginate["parts"].each do |part|
+        links << (if part["is_link"]
+                    "<a class=\"page\" href=\"#{part["url"]}\">#{part["title"]}</a>"
+                  elsif part["current"]
+                    "<span class=\"page current\">#{part["title"]}</span>"
+                  else
+                    "<span class=\"page gap\">#{part["title"]}</span>"
+                  end)
+      end
+
+      %{
+        <div class="pagination">
+          #{previous_link}
+          #{links}
+          #{next_link}
+        </div>
+      }
+    end
+
+    private
+
+    def link(type, label, paginate)
+      if paginate[type].blank?
+        "<span class=\"disabled prev-page\">#{label}</span>"
+      else
+        "<a href=\"#{paginate[type]["url"]}\" class=\"prev-page\">#{label}</a>"
+      end
+    end
+  end
+end

data/lib/shoperb_liquid/filters/theme_filters.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  module ThemeFilters
+    #
+    # returns content with values
+    # taken from settins
+    #
+    def customize(asset_path, settings_drop)
+      Theme.current.assets.find_by(
+        file: asset_path
+      ).customize(
+        settings_drop,
+        host: ShoperbLiquid.config.assets_remote_host
+      )
+    end
+
+    def image_size(image, size)
+      (image[size].try(:url) if image) || image
+    end
+  end
+end

data/lib/shoperb_liquid/filters/translate_filters.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  #
+  # Translating of strings in the theme
+  #
+  module TranslateFilters
+    def translate(string, args = {})
+      args[:theme] = @context.registers[:theme]
+      translation = ShoperbLiquid.config.translator.translate(string, **args.symbolize_keys)
+      Liquid::Template.parse(translation || "").render(args.stringify_keys)
+    end
+
+    alias_method :t, :translate
+  end
+end

data/lib/shoperb_liquid/filters/url_filters.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  module UrlFilters
+    include ActionView::Helpers::UrlHelper
+
+    def link_to_category(category)
+      link_to category.name, category.url, category.name
+    end
+
+    def link_to_product(product)
+      link_to product.name, product.url, product.name
+    end
+
+    def link_to_page(page)
+      link_to page.name, page.url, page.name
+    end
+
+    def link_to_collection(collection)
+      link_to collection.name, collection.url, collection.name
+    end
+
+    def link_to_order(obj)
+      link_to obj.name, obj.url, obj.name
+    end
+
+    def link_to_locale(text, locale)
+      link_to text, url_to_locale(locale)
+    end
+
+    def url_to_locale(locale)
+      pars = {locale: locale}
+      pars[:query] =  @context["params"]["query"] if @context["params"]["query"].present? # need for search
+
+      controller = @context.registers[:controller]
+      if @context["params"]["id"] && (obj = @context["object"]) && obj.respond_to?(:permalink)
+        pars["id"] = in_locale(locale) {obj.record.to_param}
+      end
+      controller.url_for(pars)
+    end
+
+    def link_to_root(text)
+      link_to text, "/#{@context["params"]["locale"]}"
+    end
+
+    def link_to(text, url, title=nil)
+      super text, url, title: title
+    end
+
+    private
+    def in_locale(local_locale)
+      klass = ::Shoperb::Theme::Editor::Translations
+      old = klass.locale
+      klass.locale = local_locale
+      resp = yield
+      klass.locale = old
+      resp
+    end
+  end
+end

data/lib/shoperb_liquid/registers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "request_store"
+
+module ShoperbLiquid
+  module Registers
+    extend self
+
+    def register_filters
+      Liquid::Environment.default.register_filter ShoperbLiquid::UrlFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::DatumFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::AssetFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::CollectionFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::HtmlFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::TranslateFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::ExtensionFilters
+      Liquid::Environment.default.register_filter ShoperbLiquid::ThemeFilters
+    end
+
+    def register_tags
+      Liquid::Environment.default.register_tag "layout",   ShoperbLiquid::LayoutTag
+      Liquid::Environment.default.register_tag "paginate", ShoperbLiquid::PaginateTag
+      Liquid::Environment.default.register_tag "form",     ShoperbLiquid::FormTag
+      Liquid::Environment.default.register_tag "section",  ShoperbLiquid::SectionTag
+      Liquid::Environment.default.register_tag "cache",    ShoperbLiquid::CacheTag
+      Liquid::Environment.default.register_tag "products_filter",  ShoperbLiquid::ProductsFilterTag
+      ''
+    end
+
+    def options(context, locals)
+      context.instance_eval do
+        params = self.params
+        params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+        params = params.to_h.with_indifferent_access
+
+        {
+          errors:        CollectionDrop.new(flash[:errors]),
+          meta:          MetaDrop.new(locals.delete(:meta)),
+          categories:    CategoriesDrop.new,
+          cart:          CartDrop.new(current_cart),
+          carts:         CollectionDrop.new(current_carts.map{|cart| CartDrop.new(cart)}),
+          menus:         MenusDrop.new,
+          pages:         PagesDrop.new,
+          blog_posts:    CollectionDrop.new(BlogPost.active),
+          blog_categories: CollectionDrop.new(BlogCategory.active),
+          countries:     CollectionDrop.new(Country.all),
+          vendors:       VendorsDrop.new,
+          brands:        VendorsDrop.new,
+          media_files:   CollectionDrop.new(MediaFile.includes(:file)),
+          search:        SearchDrop.new(params[:query], params[:options]),
+          shop:          ShopDrop.new(locals[:shop]),
+          current_page:  (params[:page].to_i rescue 1),
+          path:          request.path,
+          params:        params,
+          flash:         flash.to_hash.stringify_keys,
+          get_params:    request.query_parameters,
+          template_name: locals[:template].to_s,
+          url:           Url::GetDrop.new,
+          form_actions:  Url::PostDrop.new,
+          paths:         Url::PostDrop.new, # alias
+          geoip:         RequestStore["country_code"],
+          collections:   ProductCollectionsDrop.new,
+          products:      ProductsDrop.new,
+          account:       CustomerDrop.new(current_customer),
+          settings:      ThemeSettingsDrop.new(current_settings),
+          preview:       params[:theme_id].present?,
+          edit_preview:  params[:iframe_uuid].present?,
+          integrations:  IntegrationsDrop.new(locals[:shop].grouped_integrations),
+          preconnects:   defined?(ResourceHints) ? ResourceHints.preconnects : [],
+          product_types: ProductTypesDrop.new,
+          plans:         CollectionDrop.new(CustomerSubscriptionPlan.active),
+        }
+      end
+    end
+  end
+end

data/lib/shoperb_liquid/tags/cache_tag.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  #  Example {% cache product, arg1, arg2 %}
+  class CacheTag < ::Liquid::Block
+    def initialize(tag_name, markup, tokens)
+      super
+      @attrs = markup.split(/[, ]/).select(&:present?).map(&:strip)
+    end
+
+    def render(context)
+      context.stack do
+        key_lookup = [
+          "liquid.cached",
+          cache_key(context.registers[:theme]),
+          @markup,
+          ::I18n.locale.to_s,
+        ]
+
+        @attrs.each do |attr|
+          key = cache_key(context[attr])
+          key_lookup << (key || attr)
+        end
+
+        ShoperbLiquid.config.cache.fetch(key_lookup) do
+          super(context)
+        end
+      end
+    end
+
+    # using activerecord cache key when possible
+    def cache_key(object)
+      instance = nil
+      instance = object            if object.respond_to?(:updated_at)
+      instance = object.record     if object.respond_to?(:record)
+      instance = object.collection if object.respond_to?(:collection)
+
+      if instance && instance.respond_to?(:cache_key)
+        instance.cache_key
+      else
+        object
+      end
+    end
+  end
+end

data/lib/shoperb_liquid/tags/form_tag.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  # Generates feedback form
+  #
+  # Usage:
+  #
+  # {% form 'name' %}
+  #   html
+  # {% endform %}
+  # <input name="subject"> - will be used for subject. Other ones will be used for body
+  #
+  class FormTag < ::Liquid::Block
+    SYNTAX = /(#{::Liquid::QuotedFragment})/
+
+    def initialize(tag_name, markup, tokens)
+      super
+
+      if markup =~ SYNTAX
+        @subject = $1.strip[1..-2]
+      else
+        raise ShoperbLiquid::SyntaxError, "Error in tag 'layout' - Valid syntax: form 'form_name'"
+      end
+    end
+
+    def render(context)
+      context.stack do
+        nodelist = []
+        nodelist << %(<form action='/submit-form' method="post">)
+        nodelist << %(<input type="text" name="contact_form_name" value="#{@subject}" style="color: black; display: none;" />)
+        nodelist << auth_token(context)
+        nodelist << super(context)
+        nodelist << %(</form>)
+
+        nodelist.join
+      end
+    end
+
+    # returns input with protection token and honeypot protection
+    def auth_token(context)
+      controller = context.registers[:controller]
+      value = controller.send(:form_authenticity_token)
+
+      %(<input type="hidden" name="authenticity_token" value="#{value}"> <input autocomplete="nope" type="search" tabindex="-1" name="shoperb_first_last_name_1" value="" style="color: black; display: none;" />)
+    end
+  end
+end

data/lib/shoperb_liquid/tags/layout_tag.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  class LayoutTag < ::Liquid::Tag
+    SYNTAX = /(#{::Liquid::QuotedFragment}+)(\s+(#{::Liquid::QuotedFragment}+))?/
+
+    def initialize(tag_name, markup, tokens)
+      super
+
+      if markup =~ SYNTAX
+        @layout_name = $1
+      else
+        raise ShoperbLiquid::SyntaxError, "Error in tag 'layout' - Valid syntax: layout '[layout|none]'"
+      end
+    end
+
+    def render(context)
+      context.registers[:layouts] = @layout_name == "none" ? nil : @layout_name
+    end
+  end
+end

data/lib/shoperb_liquid/tags/paginate_tag.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ShoperbLiquid
+  # StrictQuotedFragment = /"[^"]+"|'[^']+'|[^\s|:,]+/
+  # FirstFilterArgument  = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
+  # OtherFilterArgument  = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
+  # SpacelessFilter      = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
+  # Expression           = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
+  # Paginate a collection
+  #
+  # Usage:
+  #
+  # {% paginate contents.projects by 5 %}
+  #   {% for project in paginate.collection %}
+  #     {{ project.name }}
+  #   {% endfor %}
+  #  {% endpaginate %}
+  #
+  class PaginateTag < ::Liquid::Block
+    Syntax = /(#{::Liquid::QuotedFragment})\s*(by\s*(\w+))?/
+    DEFAULT_PER = 20
+    MAXIMUM_PER = 100
+
+    def initialize(tag_name, markup, tokens)
+      super
+
+      if markup =~ Syntax
+        @collection_name = $1
+        @page_size       = $2 ? $3 : DEFAULT_PER # save number hardcoded or variable name
+
+        @attributes = { "window_size" => 3 }
+
+        markup.scan(Liquid::TagAttributes) do |key, value|
+          @attributes[key] = value
+        end
+      else
+        raise ShoperbLiquid::SyntaxError, "Syntax Error in 'paginate' - Valid syntax: paginate <collection> by <number>"
+      end
+
+      super
+    end
+
+    def get_page_number(per)
+      return @get_page_number if @get_page_number
+
+      @get_page_number = per.to_i
+      @get_page_number = (@context.scopes.last[per] || DEFAULT_PER).to_i if @get_page_number == 0
+      @get_page_number = MAXIMUM_PER if @get_page_number > MAXIMUM_PER
+
+      @get_page_number
+    end
+
+    # @page_size - is number or reference
+    def render(context)
+      @context = context
+
+      context.stack do
+        collection = context[@collection_name]
+        collection ||= CollectionDrop.new(Product.none)
+
+        current    = context["current_page"].to_i == 0 ? 1 : context["current_page"].to_i
+        pagy,scope = collection.send(:paginate, current, get_page_number(@page_size))
+
+        paginator = {
+          total:      pagy.count,
+          last:       pagy.count - 1,
+          pages:      pagy.pages,
+          size:       pagy.limit,
+          offset:     pagy.offset,
+          first:      1,
+          page:       current,
+          previous:   nil,
+          next:       nil,
+          parts:      [],
+          collection: scope,
+        }
+
+        path         = context["path"]
+        other_params = context["get_params"]
+
+        has_prev_page = (paginator[:page] - 1) >= 1
+        has_next_page = (paginator[:page] + 1) <= pagy.pages
+
+        previous_text = ShoperbLiquid.config.translator.translate("navigation.previous", locale: context.registers[:locale])
+        next_text = ShoperbLiquid.config.translator.translate("navigation.next", locale: context.registers[:locale])
+
+        paginator[:previous] = link(previous_text, paginator[:page] - 1, path, other_params) if has_prev_page
+        paginator[:next]     = link(next_text,     paginator[:page] + 1, path, other_params) if has_next_page
+
+        hellip_break = false
+
+        if paginator[:pages] > 1
+          1.upto(paginator[:pages]) do |page|
+            if paginator[:page] == page
+              paginator[:parts] << no_link(page)
+            elsif page == 1
+              paginator[:parts] << link(page, page, path, other_params)
+            elsif page == paginator[:pages]
+              paginator[:parts] << link(page, page, path, other_params)
+            elsif page <= paginator[:page] - window_size || page >= paginator[:page] + window_size
+              next if hellip_break
+              paginator[:parts] << no_link("&hellip;")
+              hellip_break = true
+              next
+            else
+              paginator[:parts] << link(page, page, path, other_params)
+            end
+
+            hellip_break = false
+          end
+        end
+
+        context["paginate"] = paginator.stringify_keys!
+
+        super
+      end
+    end
+
+    private
+
+    def window_size
+      @attributes["window_size"]
+    end
+
+    def no_link(title)
+      { "title" => title, "is_link" => false, "current" => title != "&hellip;" }
+    end
+
+    def link(title, page, path, other_params={})
+      params = other_params.merge("page" => page)
+      { "title" => title, "url" => path + "?#{params.to_query}", "is_link" => true }
+    end
+  end
+end