dugway 0.5.0

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

@@ -0,0 +1,129 @@
+module Dugway
+  module Tags
+    class Paginate < ::Liquid::Block
+      Syntax = /(\w+)\s+from\s+(#{ Liquid::QuotedFragment })\s*(by\s*(#{ Liquid::QuotedFragment }))?/
+
+      def initialize(tag_name, markup, tokens)
+        if markup =~ Syntax
+          @variable_name = $1
+          @collection_name = $2
+          @per_page = $3.present? ? $4 : nil
+
+          @attributes = { 'inner_window' => 3, 'outer_window' => 1 }
+
+          markup.scan(Liquid::TagAttributes) { |key, value|
+            @attributes[key] = value
+          }
+
+          @limit = @attributes['limit']
+        else
+          raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [variable] from [collection] by [number]")
+        end
+
+        super
+      end
+
+      def render(context)
+        @context = context
+        @limit = context[@limit].present? ? context[@limit] : (@limit.present? ? @limit.to_i : nil)
+        @per_page = context[@per_page].present? ? context[@per_page] : (@per_page.present? ? @per_page.to_i : nil)
+        @order = context[@attributes['order']].present? ? context[@attributes['order']] : @attributes['order']
+
+        context.stack do
+          context['internal'] = {
+            'per_page' => @per_page,
+            'order' => @order,
+            'page' => @context.registers[:params][:page] && @context.registers[:params][:page].to_i,
+            'limit' => @limit
+          }
+
+          collection = context[@collection_name]
+          context[@variable_name] = collection
+          current_page = collection.current_page
+
+          pagination = {
+            'page_size' => collection.per_page,
+            'current_page' => current_page,
+            'current_offset' => collection.offset
+          }
+
+          context['paginate'] = pagination
+
+          collection_size = collection.total_entries
+
+          raise ArgumentError.new("Cannot paginate array '#{ @collection_name }'. Not found.")  if collection_size.nil?
+
+          page_count = collection.total_pages
+
+          pagination['items'] = collection_size
+          pagination['pages'] = page_count
+
+          pagination['previous'] = collection.previous_page.blank? ? no_link('&laquo; Previous') : link('&laquo; Previous', collection.previous_page)
+
+          pagination['next'] = collection.next_page.blank? ? no_link('Next &raquo;') : link('Next &raquo;', collection.next_page)
+
+          pagination['parts'] = []
+
+          if page_count > 1
+            inner_window = @attributes['inner_window'].to_i
+            outer_window = @attributes['outer_window'].to_i
+
+            min = current_page - inner_window
+            max = current_page + inner_window
+
+            # Adjust lower or upper limit if other is out of bounds
+            if max > page_count
+              min -= max - page_count
+            elsif min < 1
+              max += 1 - min
+            end
+
+            current = min..max
+            beginning = 1..(1 + outer_window)
+            tail = (page_count - outer_window)..page_count
+            visible = [current, beginning, tail].map(&:to_a).flatten
+            visible &= (1..page_count).to_a
+
+            hellip_break = false
+
+            1.upto(page_count) { |page|
+              if page == current_page
+                pagination['parts'] << no_link(page)
+              elsif visible.include?(page)
+                pagination['parts'] << link(page, page)
+              elsif page == beginning.last + 1 || page == tail.first - 1
+                next  if hellip_break
+
+                pagination['parts'] << no_link('&hellip;')
+                hellip_break = true
+                next
+              end
+
+              hellip_break = false
+            }
+          end
+
+          render_all @nodelist, context
+        end
+      end
+
+      private
+
+      def no_link(title)
+        { 'title' => title.to_s, 'is_link' => false }
+      end
+
+      def link(title, page)
+        { 'title' => title.to_s, 'url' => current_url + "?page=#{ page }#{ search }", 'is_link' => true }
+      end
+
+      def search
+        @context.registers[:params]['search'].present? ? "&search=#{ @context.registers[:params]['search'] }" : nil
+      end
+
+      def current_url
+        @context.registers[:path]
+      end
+    end
+  end
+end

data/lib/dugway/liquifier.rb

@@ -0,0 +1,122 @@
+require 'liquid'
+require "#{ File.dirname(__FILE__) }/liquid/drops/base_drop"
+Dir.glob("#{ File.dirname(__FILE__) }/liquid/**/*.rb").each { |file| require file }
+
+Liquid::Template.register_filter(Dugway::Filters::UtilFilters)
+Liquid::Template.register_filter(Dugway::Filters::CoreFilters)
+Liquid::Template.register_filter(Dugway::Filters::DefaultPagination)
+Liquid::Template.register_filter(Dugway::Filters::UrlFilters)
+Liquid::Template.register_filter(Dugway::Filters::FontFilters)
+
+Liquid::Template.register_tag(:checkoutform, Dugway::Tags::CheckoutForm)
+Liquid::Template.register_tag(:get, Dugway::Tags::Get)
+Liquid::Template.register_tag(:paginate, Dugway::Tags::Paginate)
+
+module Dugway
+  class Liquifier
+    ESCAPE_CSS = {
+      '{{' => '"<<',
+      '}}' => '>>"',
+      '{%' => '"<',
+      '%}' => '">'
+    }
+    
+    def initialize(request)
+      @request = request
+    end
+    
+    def render(content, variables={})
+      variables.symbolize_keys!
+
+      assigns = shared_assigns
+      assigns['page_content'] = variables[:page_content]
+      assigns['page'] = Drops::PageDrop.new(variables[:page])
+      assigns['product'] = Drops::ProductDrop.new(variables[:product])
+
+      registers = shared_registers
+      registers[:category] = variables[:category]
+      registers[:artist] = variables[:artist]
+
+      if errors = variables.delete(:errors)
+        shared_context['errors'] << errors
+      end
+
+      context = Liquid::Context.new([ assigns, shared_context ], {}, registers)
+      Liquid::Template.parse(content).render!(context)
+    end
+    
+    def self.render_styles(css)
+      Liquid::Template.parse(css).render!(
+        { 'theme' => Drops::ThemeDrop.new(Dugway.theme.customization) }, 
+        :registers => { :settings => Dugway.theme.settings }
+      )
+    end
+    
+    def self.escape_styles(css)
+      ESCAPE_CSS.each_pair { |k,v| css.gsub!(k,v) }
+      css
+    end
+    
+    def self.unescape_styles(css)
+      ESCAPE_CSS.each_pair { |k,v| css.gsub!(v,k) }
+      css
+    end
+    
+    private
+
+    def store
+      Dugway.store
+    end
+
+    def theme
+      Dugway.theme
+    end
+
+    def cart
+      Dugway.cart
+    end
+
+    def shared_context
+      @shared_context ||= { 'errors' => [] }
+    end
+    
+    def shared_assigns
+      {
+        'store' => Drops::AccountDrop.new(store.account),
+        'cart' => Drops::CartDrop.new(cart),
+        'theme' => Drops::ThemeDrop.new(theme.customization),
+        'pages' => Drops::PagesDrop.new(store.pages.map { |p| Drops::PageDrop.new(p) }),
+        'categories' => Drops::CategoriesDrop.new(store.categories.map { |c| Drops::CategoryDrop.new(c) }),
+        'artists' => Drops::ArtistsDrop.new(store.artists.map { |a| Drops::ArtistDrop.new(a) }),
+        'products' => Drops::ProductsDrop.new(store.products.map { |p| Drops::ProductDrop.new(p) }),
+        'contact' => Drops::ContactDrop.new,
+        'head_content' => head_content,
+        'bigcartel_credit' => bigcartel_credit
+      }
+    end
+    
+    def shared_registers
+      {
+        :request => @request,
+        :path => @request.path,
+        :params => @request.params.with_indifferent_access,
+        :currency => store.currency,
+        :settings => theme.settings
+      }
+    end    
+    
+    def head_content
+      content = %{<meta name="generator" content="Big Cartel">}
+      
+      if google_font_url = ThemeFont.google_font_url_for_theme
+        content << %{\n<link rel="stylesheet" type="text/css" href="#{ google_font_url }">}
+      end
+      
+      content
+    end
+    
+    def bigcartel_credit
+      '<a href="http://bigcartel.com/" title="Start your own store at Big Cartel now">Online Store by Big Cartel</a>'
+    end
+  end
+end

data/lib/dugway/logger.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+module Dugway
+  class Logger < ::Logger
+    def initialize
+      Dir.mkdir(dir) unless File.exists?(dir)
+      super(File.join(dir, 'dugway.log'))
+    end
+
+    def dir
+      File.join(Dir.pwd, 'log')
+    end
+
+    alias write <<
+  end
+end

data/lib/dugway/request.rb

@@ -0,0 +1,36 @@
+module Dugway
+  class Request < Rack::Request
+    def params
+      super.update(env['rack.routing_args']).symbolize_keys
+    end
+    
+    def page_permalink
+      case path
+      when %r{^/$}
+        'home'
+      when %r{^/(products|category|artist)/}
+        'products'
+      when %r{^/product/}
+        'product'
+      else
+        File.basename(path[1..-1], '.*')
+      end
+    end
+    
+    def extension
+      File.extname(path).present? ? File.extname(path) : '.html'
+    end
+    
+    def format
+      params[:format] || extension[1..-1]
+    end
+    
+    def html?
+      format == 'html'
+    end
+
+    def js?
+      format == 'js'
+    end
+  end
+end

data/lib/dugway/store.rb

@@ -0,0 +1,166 @@
+require 'httparty'
+
+module Dugway
+  class Store
+    include HTTParty
+
+    format :json
+    default_timeout 5
+    headers 'User-Agent' => "Dugway #{ Dugway::VERSION }"
+
+    def initialize(subdomain)
+      self.class.base_uri "http://api.bigcartel.com/#{ subdomain }"
+    end
+
+    def account
+      @account ||= get('/store.js')
+    end
+    
+    def theme_pages
+      [
+        { 'name' => 'Home', 'permalink' => 'home', 'url' => '/', 'category' => 'theme' },
+        { 'name' => 'Products', 'permalink' => 'products', 'url' => '/products', 'category' => 'theme' },
+        { 'name' => 'Product', 'permalink' => 'product', 'url' => '/product', 'category' => 'theme' },
+        { 'name' => 'Cart', 'permalink' => 'cart', 'url' => '/cart', 'category' => 'theme' },
+        { 'name' => 'Checkout', 'permalink' => 'checkout', 'url' => '/checkout', 'category' => 'theme' },
+        { 'name' => 'Success', 'permalink' => 'success', 'url' => '/success', 'category' => 'theme' },
+        { 'name' => 'Contact', 'permalink' => 'contact', 'url' => '/contact', 'category' => 'theme' },
+        { 'name' => 'Maintenance', 'permalink' => 'maintenance', 'url' => '/maintenance', 'category' => 'theme' }
+      ]
+    end
+    
+    def custom_pages
+      @custom_pages ||= begin
+        custom_pages = account.has_key?('pages') ? account['pages'] : []
+        custom_pages = custom_pages.map { |page| get("/page/#{ page['permalink'] }.js") }
+      end
+    end
+
+    def pages
+      @pages ||= theme_pages + custom_pages
+    end
+    
+    def page(permalink)
+      lookup(permalink, pages)
+    end
+    
+    def categories
+      account.has_key?('categories') ? account['categories'] : []
+    end
+    
+    def category(permalink)
+      lookup(permalink, categories)
+    end
+    
+    def category_products(permalink)
+      lookup_products(permalink, 'categories')
+    end
+    
+    def artists
+      account.has_key?('artists') ? account['artists'] : []
+    end
+    
+    def artist(permalink)
+      lookup(permalink, artists)
+    end
+    
+    def artist_products(permalink)
+      lookup_products(permalink, 'artists')
+    end
+    
+    def products
+      @products ||= get('/products.js')
+    end
+    
+    def product(permalink)
+      lookup(permalink, products)
+    end
+
+    def product_and_option(option_id)
+      products.each { |product|
+        product['options'].each { |option|
+          if option['id'] == option_id
+            return product, option
+          end
+        }
+      }
+
+      nil
+    end
+
+    def previous_product(permalink)
+      products.each_with_index { |product, index|
+        if product['permalink'] == permalink && index > 0 && previous_product = products[index - 1]
+          return previous_product
+        end
+      }
+
+      nil
+    end
+
+    def next_product(permalink)
+      products.each_with_index { |product, index|
+        if product['permalink'] == permalink && (index + 1) < products.size && next_product = products[index + 1]
+          return next_product
+        end
+      }
+
+      nil
+    end
+    
+    def search_products(search_terms)
+      products.select { |p| p['name'].downcase.include?(search_terms.downcase) || p['description'].downcase.include?(search_terms.downcase) }
+    end
+    
+    def country
+      account['country']
+    end
+    
+    def currency
+      account['currency']
+    end
+    
+    def locale
+      case currency['code']
+      when 'AUD' then 'en-AU'
+      when 'BRL' then 'pt-BR'
+      when 'CAD' then 'en-US'
+      when 'CZK' then 'cs'
+      when 'DKK' then 'da'
+      when 'EUR' then 'eu'
+      when 'HKD' then 'en-US'
+      when 'HUF' then 'hu'
+      when 'ILS' then 'il'
+      when 'JPY' then 'ja'
+      when 'MYR' then 'ms-MY'
+      when 'MXN' then 'es-MX'
+      when 'TWD' then 'zh-TW'
+      when 'NZD' then 'en-US'
+      when 'NOK' then 'nb'
+      when 'PHP' then 'en-PH'
+      when 'PLN' then 'pl'
+      when 'GBP' then 'en-GB'
+      when 'SGD' then 'en-US'
+      when 'SEK' then 'sv-SE'
+      when 'CHF' then 'gsw-CH'
+      when 'THB' then 'th'
+      when 'TRY' then 'tr'
+      else 'en-US'
+      end
+    end
+    
+    private
+    
+    def get(path)
+      self.class.get(path).parsed_response
+    end
+  
+    def lookup(permalink, array)
+      array.find { |item| item['permalink'] == permalink }.try(:dup)
+    end
+    
+    def lookup_products(permalink, type)
+      products.select { |p| p[type].any? { |c| c['permalink'] == permalink }}
+    end
+  end
+end