liquid-rails 0.1.0

data/lib/liquid-rails/drops/drop.rb

@@ -0,0 +1,114 @@
+module Liquid
+  module Rails
+    class Drop < ::Liquid::Drop
+
+      class << self
+        attr_accessor :_attributes
+        attr_accessor :_associations
+      end
+
+      def self.inherited(base)
+        base._attributes   = []
+        base._associations = {}
+      end
+
+      def self.attributes(*attrs)
+        @_attributes.concat attrs
+
+        attrs.each do |attr|
+          next if method_defined?(attr)
+
+          define_method(attr) do
+            object.send(attr) if object.respond_to?(attr, true)
+          end
+        end
+      end
+
+      # By default, `Product` maps to `ProductDrop`.
+      #             Array of products maps to `Liquid::Rails::CollectionDrop`.
+      def self.drop_class_for(resource)
+        if resource.respond_to?(:to_ary)
+          Liquid::Rails::CollectionDrop
+        else
+          if self == Liquid::Rails::Drop
+            resource.drop_class || Liquid::Rails::Drop
+          else
+            self
+          end
+        end
+      end
+
+      # Create a drop instance when it cannot be inferred.
+      def self.dropify(resource, options={})
+        drop_class = if options[:class_name]
+          options[:class_name].constantize
+        else
+          drop_class_for(resource)
+        end
+
+        drop_class.new(resource, options.except(:class_name))
+      end
+
+      def self.belongs_to(*attrs)
+        associate(:belongs_to, attrs)
+      end
+
+      def self.has_many(*attrs)
+        associate(:has_many, attrs)
+      end
+
+      def self.associate(type, attrs)
+        options = attrs.extract_options!
+        self._associations = _associations.dup
+
+        attrs.each do |attr|
+          next if method_defined?(attr)
+
+          define_method attr do
+            value = instance_variable_get("@_#{attr}")
+            return value if value
+
+            association = object.send(attr)
+            return nil if association.nil?
+
+            drop_instance = Liquid::Rails::Drop.dropify(association, options)
+            instance_variable_set("@_#{attr}", drop_instance)
+          end
+
+          self._associations[attr] = { type: type, options: options }
+        end
+      end
+
+      # Wraps an object in a new instance of the drop.
+      def initialize(object, options={})
+        @object = object
+      end
+
+      def attributes
+        @attributes ||= self.class._attributes.dup.each_with_object({}) do |name, hash|
+          hash[name.to_s] = send(name)
+        end
+      end
+
+      def as_json(options={})
+        attributes.as_json(options)
+      end
+
+      def to_json(options={})
+        as_json.to_json(options)
+      end
+
+      def before_method(method)
+        attributes[method.to_s]
+      end
+
+      def inspect
+        "#<#{self.class.name} @object: #{object.inspect} @attributes: #{attributes.inspect}>"
+      end
+
+      protected
+
+        attr_reader :object
+    end
+  end
+end

data/lib/liquid-rails/drops/droppable.rb

@@ -0,0 +1,22 @@
+module Liquid
+  module Rails
+    module Droppable
+      extend ActiveSupport::Concern
+
+      def to_liquid
+        drop_class.new(self)
+      end
+      alias_method :dropify, :to_liquid
+
+      def drop_class
+        self.class.drop_class
+      end
+
+      module ClassMethods
+        def drop_class
+          "#{self.name}Drop".safe_constantize
+        end
+      end
+    end
+  end
+end

data/lib/liquid-rails/file_system.rb

@@ -0,0 +1,14 @@
+require 'liquid/file_system'
+
+module Liquid
+  module Rails
+    class FileSystem < ::Liquid::LocalFileSystem
+      def read_template_file(template_path, context)
+        controller_name = context.registers[:controller].controller_name
+        template_path   = "#{controller_name}/#{template_path}" unless template_path.include?('/')
+
+        super
+      end
+    end
+  end
+end

data/lib/liquid-rails/filters/asset_tag_filter.rb

@@ -0,0 +1,25 @@
+module Liquid
+  module Rails
+    module AssetTagFilter
+      delegate \
+                :audio_tag,
+                :auto_discovery_link_tag,
+                :favicon_link_tag,
+                :image_alt,
+                :image_tag,
+                :javascript_include_tag,
+                :stylesheet_link_tag,
+                :video_tag,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::AssetTagFilter)

data/lib/liquid-rails/filters/asset_url_filter.rb

@@ -0,0 +1,37 @@
+module Liquid
+  module Rails
+    module AssetUrlFilter
+      delegate \
+                :asset_path,
+                :asset_url,
+
+                :audio_path,
+                :audio_url,
+
+                :font_path,
+                :font_url,
+
+                :image_path,
+                :image_url,
+
+                :javascript_path,
+                :javascript_url,
+
+                :stylesheet_path,
+                :stylesheet_url,
+
+                :video_path,
+                :video_url,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::AssetUrlFilter)

data/lib/liquid-rails/filters/date_filter.rb

@@ -0,0 +1,19 @@
+module Liquid
+  module Rails
+    module DateFilter
+      delegate \
+                :distance_of_time_in_words,
+                :time_ago_in_words,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::DateFilter)

data/lib/liquid-rails/filters/google_static_map_url_filter.rb

@@ -0,0 +1,30 @@
+module Liquid
+  module Rails
+    module GoogleStaticMapUrlFilter
+
+      # size:     '600x300'
+      #
+      # Available keys inside options
+      # center:   '40.714728,-73.998672'
+      # zoom:     13
+      # maptype:  'roadmap', 'satellite', 'terrain', or 'hybrid'
+      # markers:  an array of this 'color:blue|label:S|40.702147,-74.015794'
+      #           or string with semicolon
+      def google_static_map_url(size, options={})
+        markers = options.delete('markers')
+        markers = if markers
+          markers = markers.split(';') if markers.is_a?(String)
+          markers.map { |marker| { markers: marker }.to_query }
+        else
+          ''
+        end
+        options = options.merge('size' => size)
+        querystring = [options.to_query, markers].delete_if { |value| value.blank? }.join('&')
+
+        "https://maps.googleapis.com/maps/api/staticmap?#{querystring}"
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::GoogleStaticMapUrlFilter)

data/lib/liquid-rails/filters/misc_filter.rb

@@ -0,0 +1,47 @@
+require 'json'
+
+module Liquid
+  module Rails
+    module MiscFilter
+      # Get the nth element of the passed in array
+      def index(array, position)
+        array.at(position) if array.respond_to?(:at)
+      end
+
+      def random(input)
+        rand(input.to_i)
+      end
+
+      def jsonify(object)
+        JSON.dump(object)
+      end
+
+      # If condition is true, the class_name is returned. Otherwise, it returns nil.
+      # class_name: css class name
+      # condition: boolean
+      def toggle_class_name(class_name, condition)
+        condition ? class_name : nil
+      end
+
+      def default_pagination(paginate)
+        html = []
+        html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
+
+        for part in paginate['parts']
+          if part['is_link']
+            html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+          elsif part['title'].to_i == paginate['current_page'].to_i
+            html << %(<span class="page current">#{part['title']}</span>)
+          else
+            html << %(<span class="deco">#{part['title']}</span>)
+          end
+        end
+
+        html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
+        html.join(' ')
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::MiscFilter)

data/lib/liquid-rails/filters/number_filter.rb

@@ -0,0 +1,24 @@
+module Liquid
+  module Rails
+    module NumberFilter
+      delegate \
+                :number_to_phone,
+                :number_to_currency,
+                :number_to_percentage,
+                :number_with_delimiter,
+                :number_with_precision,
+                :number_to_human_size,
+                :number_to_human,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::NumberFilter)

data/lib/liquid-rails/filters/sanitize_filter.rb

@@ -0,0 +1,19 @@
+module Liquid
+  module Rails
+    module SanitizeFilter
+      delegate \
+                :strip_tags,
+                :strip_links,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::SanitizeFilter)

data/lib/liquid-rails/filters/text_filter.rb

@@ -0,0 +1,47 @@
+module Liquid
+  module Rails
+    module TextFilter
+      delegate \
+                :truncate,
+                :highlight,
+                :excerpt,
+                :pluralize,
+                :word_wrap,
+                :simple_format,
+
+                to: :h
+
+      # right justify and padd a string
+      def rjust(input, integer, padstr = '')
+        input.to_s.rjust(integer, padstr)
+      end
+
+      # left justify and padd a string
+      def ljust(input, integer, padstr = '')
+        input.to_s.ljust(integer, padstr)
+      end
+
+      def underscore(input)
+        input.to_s.gsub(' ', '_').gsub('/', '_').underscore
+      end
+
+      def dasherize(input)
+        input.to_s.gsub(' ', '-').gsub('/', '-').dasherize
+      end
+
+      def concat(input, *args)
+        result = input.to_s
+        args.flatten.each { |a| result << a.to_s }
+        result
+      end
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::TextFilter)

data/lib/liquid-rails/filters/translate_filter.rb

@@ -0,0 +1,13 @@
+module Liquid
+  module Rails
+    module TranslateFilter
+      def translate(key, locale = nil, scope = nil)
+        locale ||= ::I18n.locale.to_s
+
+        @context.registers[:view].translate(key.to_s, locale: locale, scope: scope)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter Liquid::Rails::TranslateFilter

data/lib/liquid-rails/filters/url_filter.rb

@@ -0,0 +1,24 @@
+module Liquid
+  module Rails
+    module UrlFilter
+
+      def link_to(name, url, options={})
+        @context.registers[:view].link_to(name, url.to_s, options)
+      end
+
+      def link_to_unless_current(name, url, options={})
+        @context.registers[:view].link_to_unless_current(name, url.to_s, options)
+      end
+
+      def mail_to(email_address, name=nil, options={})
+        @context.registers[:view].mail_to(email_address, name, options)
+      end
+
+      def current_page?(path)
+        @context.registers[:view].current_page?(path.to_s)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::UrlFilter)