dugway 0.5.0

data/lib/dugway/liquid/filters/comparison_filters.rb

@@ -0,0 +1,48 @@
+module Dugway
+  module Filters
+    module ComparisonFilters
+      def num_gt(input, operand)
+        to_number(input) > to_number(operand)
+      end
+
+      def num_lt(input, operand)
+        to_number(input) < to_number(operand)
+      end
+
+      def num_eq(input, operand)
+        to_number(input) == to_number(operand)
+      end
+
+      def num_lte(input, operand)
+        num_eq(input, operand) || num_lt(input, operand)
+      end
+
+      def num_gte(input, operand)
+        num_eq(input, operand) || num_gt(input, operand)
+      end
+
+      private
+
+      def to_number(obj)
+        case obj
+        when Numeric
+          obj
+        when String
+          (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+        else
+          0
+        end
+      end
+    end
+  end
+end
+
+Liquid::Condition.send(:include, Dugway::Filters::ComparisonFilters)
+
+Liquid::Condition.class_eval do
+  operators['num_lt']  = lambda { |cond, left, right| cond.num_lt(left, right) }
+  operators['num_lte'] = lambda { |cond, left, right| cond.num_lte(left, right) }
+  operators['num_gt']  = lambda { |cond, left, right| cond.num_gt(left, right) }
+  operators['num_gte'] = lambda { |cond, left, right| cond.num_gte(left, right) }
+  operators['num_eq']  = lambda { |cond, left, right| cond.num_eq(left, right) }
+end

data/lib/dugway/liquid/filters/core_filters.rb

@@ -0,0 +1,138 @@
+require 'htmlentities'
+
+module Dugway
+  module Filters
+    module CoreFilters
+      # Text Filters
+
+      def pluralize(count, singular, plural = nil)
+        "#{count} " + if count == 1
+          singular
+        elsif plural
+          plural
+        else
+          singular + "s"
+        end
+      end
+
+      def paragraphs(text)
+        tags   = '(table|thead|tfoot|caption|colgroup|tbody|tr|td|th|div|dl|dd|dt|ul|ol|li|pre|select|form|map|area|blockquote|address|math|style|input|p|h[1-6]|hr|script|embed|object|param|code|center|dir|fieldset|menu|noframes|noscript|frameset|applet|button|del|iframe|ins)' 
+        text   = text.to_s.gsub(/\r\n?/, "\n") # \r\n and \r -> \n          
+        blocks = text.split(/\n\n+/) # split on double newlines
+        blocks.inject('') do | result, block |
+          block.strip!
+          if block =~ /<\s*(\/)?\s*#{tags}\s*(\/)?\s*>.*(<\s*\/\s*\1\s*>)?/i
+            result << block
+          else
+            block.gsub!(/([^\n]\n)(?=[^\n])/, '\1<br />')  # 1 newline -> br
+            result << "<p>#{block}</p>"
+          end
+          result << "\n"
+        end
+      end
+
+      # Money Filters
+
+      def money(amount)
+        number_to_currency(amount, :locale => nil, :precision => I18n.translate('number.currency.format.precision'), :unit => '', :separator => I18n.translate('number.currency.format.separator'), :delimiter => I18n.translate('number.currency.format.delimiter'), :format => I18n.translate('number.currency.format.format')).strip
+      end
+
+      def money_with_sign(amount)
+        unit = I18n.translate('number.currency.format.unit')
+        number_to_currency(amount).try(:gsub, unit, "<span class=\"currency_sign\">#{ HTMLEntities.new.encode(unit, :named) }</span>")
+      end
+
+      def money_with_code(amount)
+        %{#{ money(amount) } <span class="currency_code">#{ currency.code }</span>}
+      end
+
+      def money_with_sign_and_code(amount)
+        %{#{ money_with_sign(amount) } <span class="currency_code\">#{ currency.code }</span>}
+      end
+
+      # Shipping Filters
+
+      def shipping_name(area, everywhere = 'Everywhere', everywhere_else = 'Everywhere else')
+        if area.country.name.present?
+          area.country['name']
+        elsif area.strict
+          everywhere_else
+        else
+          everywhere
+        end
+      end
+
+      # Input Filters
+
+      def hidden_option_input(option, id = 'option', class_name = nil)
+        hidden_field_tag('cart[add][id]', option['id'], { :id => id, :class => class_name })
+      end
+
+      def options_select(options, id = 'option', class_name = nil)
+        options = options.present? ? options : []
+        option_tags = options.inject('') { |t,o| t += option_tag((o['name'] + (o['has_custom_price'] ? " - #{ money_with_sign(o['price']) }" : '')), o['id']) }
+        select_tag('cart[add][id]', option_tags, { :id => id, :class => class_name })
+      end
+      
+      def options_radio(options, id = 'option', class_name = nil)
+        list = ''
+        
+        for o in options
+          list += '<li>'
+          list += radio_button_tag('cart[add][id]', o['id'], o['default'], { :id => "option_#{o['id']}", :class => class_name })
+          list += %{ <label for="option_#{o['id']}">#{o['name']}}
+          list += %{ - #{ money_with_sign(o['price']) }} if o['has_custom_price']
+          list += %{</label>}
+          list += '</li>'
+        end
+        
+        %{<ul id="#{id}">#{list}</ul>}
+      end
+
+      def product_quantity_input(product, quantity = 1, id = nil, class_name = nil)
+        text_field_tag("cart[add][quantity]", quantity, { :id => id || "quantity_#{product['id']}", :class => class_name, :autocomplete => 'off' })
+      end
+
+      def item_quantity_input(item, id = nil, class_name = nil)
+        text_field_tag("cart[update][#{ item['id'] }]", item['quantity'], { :id => id || "item_#{ item['id'] }_qty", :class => class_name, :autocomplete => 'off' })
+      end
+
+      def country_select(country, label = 'Select your country...', id = 'country', class_name = nil)
+        found     = false
+        countries = [[label, ''], ['------------',''], [country['name'], country['id']], ['------------','']] + Country.options
+        options   = countries.inject('') do |t,c|
+          select  = !found && c[1] == cart.country_id
+          found   = true if select
+          t += option_tag(c[0], c[1], select)
+        end
+        select_tag('cart[country_id]', options, { :id => id, :class => class_name })
+      end
+
+      def discount_code_input(discount, id = 'cart_discount_code', class_name = nil)
+        text_field_tag('cart[discount_code]', nil, { :id => id, :class => class_name, :autocomplete => 'off' })
+      end
+
+      # Contact Filters
+
+      def contact_input(contact, field, id = nil, class_name = nil)
+        field = field.downcase
+        id    ||= field
+        case field
+        when 'message'
+          text_area_tag(field, contact['message'], :id => id, :class => class_name, :tabindex => contact_tab_index)
+        when 'captcha'
+          text_field_tag('captcha', '', :id => id, :class => class_name, :tabindex => contact_tab_index)
+        else
+          text_field_tag(field, contact[field], :id => id, :class => class_name, :tabindex => contact_tab_index)
+        end
+      end
+
+      private
+
+      def contact_tab_index
+        @contact_tab_index ||= 0
+        @contact_tab_index += 1
+      end  
+    end
+  end
+end

data/lib/dugway/liquid/filters/default_pagination.rb

@@ -0,0 +1,35 @@
+module Dugway
+  module Filters
+    module DefaultPagination
+      def default_pagination(paginate, div_id = 'pagination', div_class = 'pagination', prev_label = nil, next_label = nil)
+        Array.new.tap { |html|
+          html << %(<div class="#{ div_class }" id="#{ div_id }">)
+
+          prev_label = prev_label.blank? ? paginate['previous']['title'] : prev_label
+          if paginate['previous']['is_link']
+            html << %(<a class="previous" href="#{ paginate['previous']['url'] }">#{ prev_label }</a>)
+          else
+            html << %(<span class="previous disabled">#{ prev_label }</span>)
+          end
+
+          paginate['parts'].each { |part|
+            if part['is_link']
+              html << %(<a href="#{ part['url'] }">#{ part['title'] }</a>)
+            else
+              html << %(<span class="#{ part['title'] == paginate['current_page'].to_s ? 'current' : 'gap' }">#{ part['title'] }</span>)
+            end
+          }
+
+          next_label = next_label.blank? ? paginate['next']['title'] : next_label
+          if paginate['next']['is_link']
+            html << %(<a class="next" href="#{ paginate['next']['url'] }">#{ next_label }</a>)
+          else
+            html << %(<span class="next disabled">#{ next_label }</span>)
+          end
+
+          html << %(</div>)
+        }.join(' ')
+      end
+    end
+  end
+end

data/lib/dugway/liquid/filters/font_filters.rb

@@ -0,0 +1,9 @@
+module Dugway
+  module Filters
+    module FontFilters
+      def font_family(font_name)
+        ThemeFont.find_family_by_name(font_name)
+      end
+    end
+  end
+end

data/lib/dugway/liquid/filters/url_filters.rb

@@ -0,0 +1,66 @@
+module Dugway
+  module Filters
+    module UrlFilters
+      def link_to(item, *args)
+        options = link_args_to_options(args)
+        text = options.delete(:text) || h(item['name'])
+        options = { :title => "View #{ text }", :href => item['url'] }.merge(options)
+        content_tag :a, text, options
+      end
+
+      def product_image_url(image=nil, size=nil)
+        unless image.blank?
+          url = image['url']
+
+          unless size.blank?
+            size = size.to_s.downcase
+
+            if thumb_size_in_pixels = thumb_size_in_pixels_for(size)
+              dir = url[0..url.rindex('/')]
+              ext = File.extname(url)
+              url = "#{ dir }#{ thumb_size_in_pixels }#{ ext }"
+            end
+          end
+        else
+          url = "http://bigcartel.com/images/common/noimage-#{ (size || 'large').to_s }.gif"
+        end
+
+        url
+      end
+
+      def theme_js_url(name)
+        if name.is_a?(Drops::ThemeDrop)
+          '/scripts.js'
+        elsif name == 'api'
+          'http://cache0.bigcartel.com/api/1/api.usd.js'
+        else
+          name
+        end
+      end
+
+      def theme_css_url(theme)
+        '/styles.css'
+      end
+
+      def theme_image_url(filename)
+        "/images/#{ filename }"
+      end
+
+      private
+
+      def link_args_to_options(args)
+        options = {}
+
+        [:text, :title, :id, :class, :rel].zip(args) { |key, value|
+          options[key] = h(value)  unless value.nil?
+        }
+
+        options
+      end
+
+      def thumb_size_in_pixels_for(size)
+        { 'thumb' => 75, 'medium' => 175, 'large' => 300 }[size]
+      end
+    end
+  end
+end

data/lib/dugway/liquid/filters/util_filters.rb

@@ -0,0 +1,119 @@
+module Dugway
+  module Filters
+    module UtilFilters
+      private
+
+      # Registered Vars
+
+      def currency
+        @context.registers[:currency]
+      end
+
+      # Mimics
+      
+      DEFAULT_CURRENCY_VALUES = { :format => "%u%n", :negative_format => "-%u%n", :unit => "$", :separator => ".", :delimiter => ",", :precision => 2, :significant => false, :strip_insignificant_zeros => false }
+      
+      def number_to_currency(number, options={})
+        return unless number
+        
+        options.symbolize_keys!
+
+        defaults  = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
+        currency  = I18n.translate(:'number.currency.format', :locale => options[:locale], :default => {})
+        currency[:negative_format] ||= "-" + currency[:format] if currency[:format]
+
+        defaults  = DEFAULT_CURRENCY_VALUES.merge(defaults).merge!(currency)
+        defaults[:negative_format] = "-" + options[:format] if options[:format]
+        options   = defaults.merge!(options)
+
+        unit      = options.delete(:unit)
+        format    = options.delete(:format)
+
+        if number.to_f < 0
+          format = options.delete(:negative_format)
+          number = number.respond_to?("abs") ? number.abs : number.sub(/^-/, '')
+        end
+        
+        value = number_with_precision(number, options[:precision])
+        format.gsub(/%n/, value).gsub(/%u/, unit)
+      end
+
+      def number_with_delimiter(number, delimiter=",", separator=".")
+        begin
+          parts = number.to_s.split('.')
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+          parts.join separator
+        rescue
+          number
+        end
+      end
+
+      def number_with_precision(number, precision=3)
+        "%01.#{precision}f" % number
+      rescue
+        number
+      end
+
+      def tag(name, options = nil, open = false, escape = true)
+        "<#{name}#{tag_options(options, escape) if options}" + (open ? ">" : " />")
+      end
+
+      def tag_options(options, escape = true)
+        unless options.blank?
+          attrs = []
+          if escape
+            options.each do |key, value|
+              next unless value
+              key = h(key.to_s)
+              value = h(value)
+              attrs << %(#{key}="#{value}")
+            end
+          else
+            attrs = options.map { |key, value| %(#{key}="#{value}") }
+          end
+          " #{attrs.sort * ' '}" unless attrs.empty?
+        end
+      end
+
+      def content_tag(type, content, options = {})
+        result  = tag(type, options, true)
+        result += content
+        result += "</#{type}>"
+      end
+
+      def select_tag(name, option_tags = nil, options = {})
+        content_tag :select, option_tags, { "name" => name, "id" => name }.update(options.stringify_keys)
+      end
+
+      def option_tag(name, value, selected=false)
+        content_tag :option, name, { :value => value, :selected => selected ? 'selected' : nil }
+      end
+
+      def text_field_tag(name, value = nil, options = {})
+        tag(:input, { "type" => "text", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys))
+      end
+
+      def hidden_field_tag(name, value = nil, options = {})
+        text_field_tag(name, value, options.stringify_keys.update("type" => "hidden"))
+      end
+
+      def text_area_tag(name, content = nil, options = {})
+        options.stringify_keys!
+
+        if size = options.delete("size")
+          options["cols"], options["rows"] = size.split("x") if size.respond_to?(:split)
+        end
+
+        content_tag :textarea, content, { "name" => name, "id" => name }.update(options)
+      end
+
+      def radio_button_tag(name, value, checked = false, options = {})
+        pretty_tag_value = value.to_s.gsub(/\s/, "_").gsub(/(?!-)\W/, "").downcase
+        pretty_name = name.to_s.gsub(/\[/, "_").gsub(/\]/, "")
+        html_options = { "type" => "radio", "name" => name, "id" => "#{pretty_name}_#{pretty_tag_value}", "value" => value }.update(options.stringify_keys)
+        html_options["checked"] = "checked" if checked
+        tag :input, html_options
+      end
+    end
+  end
+end

data/lib/dugway/liquid/tags/checkout_form.rb

@@ -0,0 +1,9 @@
+module Dugway
+  module Tags
+    class CheckoutForm < ::Liquid::Block
+      def render(context)
+        %{<form id="checkout_form" name="checkout_form" method="post" action="/success"></form>}
+      end
+    end
+  end
+end

data/lib/dugway/liquid/tags/get.rb

@@ -0,0 +1,58 @@
+module Dugway
+  module Tags
+    class Get < ::Liquid::Block
+      Syntax = /((#{ Liquid::QuotedFragment })\s+)?(\w+)\s+from\s+(#{ Liquid::QuotedFragment }+)/
+
+      def initialize(tag_name, markup, tokens)
+        if markup =~ Syntax
+          @number_to_get = $1.present? ? $2 : nil
+          @variable_name = $3
+          @collection_name = $4
+
+          @attributes = {}
+          markup.scan(Liquid::TagAttributes) { |key, value|
+            @attributes[key] = value
+          }
+        else
+          raise SyntaxError.new("Syntax Error in tag 'get' - Valid syntax: get [number] [items] from [collection] order:[order]")
+        end
+
+        super
+      end
+
+      def render(context)
+        @context = context
+
+        @number_to_get = if context[@number_to_get].present?
+          context[@number_to_get]
+        elsif @number_to_get.present?
+          @number_to_get.to_i
+        elsif @attributes['limit'].present?
+          if context[@attributes['limit']].present?
+            context[@attributes['limit']]
+          else
+            @attributes['limit'].to_i
+          end
+        else
+          nil
+        end
+
+        @order = context[@attributes['order']].present? ? context[@attributes['order']] : @attributes['order']
+
+        context.stack do
+          context['internal'] = {
+            'per_page' => @number_to_get,
+            'order' => @order,
+            'page' => nil
+          }
+
+          context[@variable_name] = context[@collection_name]
+
+          raise ArgumentError.new("Cannot get array '#{ @collection_name }'. Not found.")  if context[@variable_name].total_entries.nil?
+
+          render_all @nodelist, context
+        end
+      end
+    end
+  end
+end