liquor 0.1.1 → 0.9.1

data/lib/liquor/errors.rb

@@ -1,11 +0,0 @@
-module Liquor
-  class Error < ::StandardError; end
-  
-  class ArgumentError < Error; end
-  class ContextError < Error; end
-  class FilterNotFound < Error; end
-  class FileSystemError < Error; end
-  class StandardError < Error; end
-  class SyntaxError < Error; end
-  class StackLevelError < Error; end
-end

data/lib/liquor/extensions.rb

@@ -1,72 +0,0 @@
-require 'time'
-require 'date'
-
-class String # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-class Array  # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-class Hash  # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-class Numeric  # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-class Time  # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-class DateTime < Date  # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-class Date  # :nodoc:
-  def to_liquor
-    self
-  end
-end
-
-def true.to_liquor  # :nodoc:
-  self
-end
-
-def false.to_liquor # :nodoc:
-  self
-end
-
-def nil.to_liquor # :nodoc:
-  self
-end
-
-class ActiveRecord::Relation
-  def to_liquor
-    self
-  end
-end
-
-class ActionDispatch::Request
-  def to_liquor
-    Liquor::RequestDrop.new self
-  end
-end
-
-class Liquor::RequestDrop < Liquor::Drop
-  allow_all_methods
-end

data/lib/liquor/file_system.rb

@@ -1,62 +0,0 @@
-module Liquor
-  # A liquor file system is way to let your templates retrieve other templates for use with the include tag.
-  #
-  # You can implement subclasses that retrieve templates from the database, from the file system using a different 
-  # path structure, you can provide them as hard-coded inline strings, or any manner that you see fit.
-  #
-  # You can add additional instance variables, arguments, or methods as needed.
-  #
-  # Example:
-  #
-  # Liquor::Template.file_system = Liquor::LocalFileSystem.new(template_path)
-  # liquor = Liquor::Template.parse(template)
-  #
-  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
-  class BlankFileSystem
-    # Called by Liquor to retrieve a template file
-    def read_template_file(template_path)
-      raise FileSystemError, "This liquor context does not allow includes."
-    end
-  end
-  
-  # This implements an abstract file system which retrieves template files named in a manner similar to Rails partials,
-  # ie. with the template name prefixed with an underscore. The extension ".liquor" is also added.
-  #
-  # For security reasons, template paths are only allowed to contain letters, numbers, and underscore.
-  #
-  # Example:
-  #
-  # file_system = Liquor::LocalFileSystem.new("/some/path")
-  # 
-  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquor"
-  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquor"
-  #
-  class LocalFileSystem
-    attr_accessor :root
-    
-    def initialize(root)
-      @root = root
-    end
-    
-    def read_template_file(template_path)
-      full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
-      
-      File.read(full_path)
-    end
-    
-    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
-      
-      full_path = if template_path.include?('/')
-        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquor")
-      else
-        File.join(root, "_#{template_path}.liquor")
-      end
-      
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
-      
-      full_path
-    end
-  end
-end

data/lib/liquor/htmltags.rb

@@ -1,74 +0,0 @@
-module Liquor
-  class TableRow < Block
-    Syntax = /(\w+)\s+in\s+(#{VariableSignature}+)/
-
-    def initialize(tag_name, markup, tokens)
-      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @attributes = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
-        end
-      else
-        raise SyntaxError.new("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")
-      end
-
-      super
-    end
-
-    def render(context)
-      collection = context[@collection_name] or return ''
-
-      if @attributes['limit'] or @attributes['offset']
-        limit = context[@attributes['limit']] || -1
-        offset = context[@attributes['offset']] || 0
-        collection = collection[offset.to_i..(limit.to_i + offset.to_i - 1)]
-      end
-
-      length = collection.length
-
-      cols = context[@attributes['cols']].to_i
-
-      row = 1
-      col = 0
-
-      result = ["<tr class=\"row1\">\n"]
-      context.stack do
-
-        collection.each_with_index do |item, index|
-          context[@variable_name] = item
-          context['tablerowloop'] = {
-            'length'  => length,
-            'index'   => index + 1,
-            'index0'  => index,
-            'col'     => col + 1,
-            'col0'    => col,
-            'index0'  => index,
-            'rindex'  => length - index,
-            'rindex0' => length - index -1,
-            'first'   => (index == 0),
-            'last'    => (index == length - 1),
-            'col_first' => (col == 0),
-            'col_last'  => (col == cols - 1)
-          }
-
-
-          col += 1
-
-          result << ["<td class=\"col#{col}\">"] + render_all(@nodelist, context) + ['</td>']
-
-          if col == cols and not (index == length - 1)
-            col  = 0
-            row += 1
-            result << ["</tr>\n<tr class=\"row#{row}\">"]
-          end
-
-        end
-      end
-      result + ["</tr>\n"]
-    end
-  end
-
-  Template.register_tag('tablerow', TableRow)
-end

data/lib/liquor/module_ex.rb

@@ -1,60 +0,0 @@
-# Copyright 2007 by Domizio Demichelis
-# This library is free software. It may be used, redistributed and/or modified
-# under the same terms as Ruby itself
-#
-# This extension is usesd in order to expose the object of the implementing class
-# to liquor as it were a Drop. It also limits the liquor-callable methods of the instance
-# to the allowed method passed with the liquor_methods call
-# Example:
-#
-# class SomeClass
-#   liquor_methods :an_allowed_method
-#
-#   def an_allowed_method
-#     'this comes from an allowed method'
-#   end
-#   def unallowed_method
-#     'this will never be an output'
-#   end
-# end
-#
-# if you want to extend the drop to other methods you can defines more methods
-# in the class <YourClass>::LiquorDropClass
-#
-#   class SomeClass::LiquorDropClass
-#     def another_allowed_method
-#       'and this from another allowed method'
-#     end
-#   end
-# end
-#
-# usage:
-# @something = SomeClass.new
-#
-# template:
-# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
-#
-# output:
-# 'this comes from an allowed method and this from another allowed method'
-#
-# You can also chain associations, by adding the liquor_method call in the
-# association models.
-#
-class Module
-
-  def liquor_methods(*allowed_methods)
-    drop_class_str = "class #{self.to_s}::LiquorDropClass < Liquor::Drop\n"
-    drop_class_str += "class_attribute :liquor_attributes\n"
-    drop_class_str += "self.liquor_attributes = []\n"
-    drop_class_str += "liquor_attributes << #{allowed_methods.collect{|meth| ":#{meth}"}.join(" << ") }\n" if allowed_methods.present?
-    drop_class_str += "self\n"
-    drop_class_str += "end"
-
-    drop_class = eval drop_class_str
-
-    define_method :to_liquor do
-      drop_class.new(self)
-    end
-  end
-
-end

data/lib/liquor/standardfilters.rb

@@ -1,315 +0,0 @@
-require 'cgi'
-
-module Liquor
-  
-  module StandardFilters
-    
-    # Return the size of an array or of a string
-    def size(input)
-      
-      input.respond_to?(:size) ? input.size : 0
-    end         
-    
-    # convert a input string to DOWNCASE
-    def downcase(input)
-      input.to_s.downcase
-    end         
-
-    # convert a input string to UPCASE
-    def upcase(input)
-      input.to_s.upcase
-    end
-    
-    # capitalize words in the input sentence
-    def capitalize(input)
-      input.to_s.capitalize
-    end
-        
-    def escape(input)
-      CGI.escapeHTML(input) rescue input
-    end
-    
-    # escape_once
-    def escape_once(input)
-      ActionView::Helpers::TagHelper.escape_once(input) rescue input	
-    end
-    
-    alias_method :h, :escape
-    
-    # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...")
-      if input.nil? then return end
-      l = length.to_i - truncate_string.length
-      l = 0 if l < 0
-      input.length > length.to_i ? input.mb_chars[0...l].to_s + truncate_string : input
-    end
-
-    def truncatewords(input, words = 15, truncate_string = "...")
-      if input.nil? then return end
-      wordlist = input.to_s.split
-      l = words.to_i - 1
-      l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input 
-    end
-    
-    def strip_html(input)
-      input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<.*?>/, '')
-    end       
-    
-    # Remove all newlines from the string
-    def strip_newlines(input)        
-      input.to_s.gsub(/\n/, '')      
-    end
-    
-    
-    # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
-      [input].flatten.join(glue)
-    end
-
-    # Sort elements of the array
-    # provide optional property with which to sort an array of hashes or drops
-    def sort(input, property = nil)
-      ary = [input].flatten
-      if property.nil?
-        ary.sort
-      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
-        ary.sort {|a,b| a[property] <=> b[property] }
-      elsif ary.first.respond_to?(property)
-        ary.sort {|a,b| a.send(property) <=> b.send(property) }
-      end
-    end               
-    
-    # map/collect on a given property
-    def map(input, property)
-      ary = [input].flatten
-      if ary.first.respond_to?('[]') and !ary.first[property].nil?
-        ary.map {|e| e[property] }
-      elsif ary.first.respond_to?(property)
-        ary.map {|e| e.send(property) }
-      end
-    end
-            
-    # Replace occurrences of a string with another
-    def replace(input, string, replacement = '')
-      input.to_s.gsub(string, replacement)
-    end
-                                                 
-    # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = '')
-      input.to_s.sub(string, replacement)
-    end              
-                                                           
-    # remove a substring
-    def remove(input, string)
-      input.to_s.gsub(string, '')      
-    end
-                        
-    # remove the first occurrences of a substring
-    def remove_first(input, string)
-      input.to_s.sub(string, '')      
-    end             
-                              
-    # add one string to another
-    def append(input, string)
-      input.to_s + string.to_s
-    end
-                                
-    # prepend a string to another
-    def prepend(input, string)
-      string.to_s + input.to_s
-    end
-                                             
-    # Add <br /> tags in front of all newlines in input string
-    def newline_to_br(input)        
-      input.to_s.gsub(/\n/, "<br />\n")      
-    end
-    
-    # Reformat a date
-    #
-    #   %a - The abbreviated weekday name (``Sun'')
-    #   %A - The  full  weekday  name (``Sunday'')
-    #   %b - The abbreviated month name (``Jan'')
-    #   %B - The  full  month  name (``January'')
-    #   %c - The preferred local date and time representation
-    #   %d - Day of the month (01..31)
-    #   %H - Hour of the day, 24-hour clock (00..23)
-    #   %I - Hour of the day, 12-hour clock (01..12)
-    #   %j - Day of the year (001..366)
-    #   %m - Month of the year (01..12)
-    #   %M - Minute of the hour (00..59)
-    #   %p - Meridian indicator (``AM''  or  ``PM'')
-    #   %S - Second of the minute (00..60)
-    #   %U - Week  number  of the current year,
-    #           starting with the first Sunday as the first
-    #           day of the first week (00..53)
-    #   %W - Week  number  of the current year,
-    #           starting with the first Monday as the first
-    #           day of the first week (00..53)
-    #   %w - Day of the week (Sunday is 0, 0..6)
-    #   %x - Preferred representation for the date alone, no time
-    #   %X - Preferred representation for the time alone, no date
-    #   %y - Year without a century (00..99)
-    #   %Y - Year with century
-    #   %Z - Time zone name
-    #   %% - Literal ``%'' character
-    def date(input, format)
-      
-      if format.to_s.empty?
-        return input.to_s
-      end
-      
-      date = input.is_a?(String) ? Time.parse(input) : input
-      
-      if date.respond_to?(:strftime)
-        date.strftime(format.to_s)
-      else
-        input
-      end
-    rescue => e 
-      input
-    end
-    
-    # Get the first element of the passed in array 
-    # 
-    # Example:
-    #    {{ product.images | first | to_img }}
-    #  
-    def first(array)
-      array.first if array.respond_to?(:first)
-    end
-
-    # Get the last element of the passed in array 
-    # 
-    # Example:
-    #    {{ product.images | last | to_img }}
-    #  
-    def last(array)
-      array.last if array.respond_to?(:last)
-    end
-    
-    # addition
-    def plus(input, operand)
-      input + operand if input.respond_to?('+')
-    end
-    
-    # subtraction
-    def minus(input, operand)
-      input - operand if input.respond_to?('-')
-    end
-    
-    # multiplication
-    def times(input, operand)
-      input * operand if input.respond_to?('*')
-    end
-    
-    # division
-    def divided_by(input, operand)
-      input / operand if input.respond_to?('/')
-    end
-    
-    # to_number / to_i
-    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
-    alias :to_i :to_number
-    
-    # to_string / to_s, supposed to be used against Numeric objects
-    def to_string(obj)
-      case obj
-      when Numeric
-        obj.to_s
-      else
-        obj
-      end
-    end
-    alias :to_s :to_string
-    
-    # yeild for content_for tag
-    def yield(name)
-      return '' if name.blank?
-
-      res = @context["content_for"][name]
-      if res.present? && res.is_a?(Array)
-        res = res.first
-      elsif res.blank?
-        res = ''
-      end
-
-      res
-    end
-    
-    # splits over the array in groups of size num padding any remaining slots with fill_with unless it is false
-    def in_groups_of(array, num, fill_with = nil)
-      array.in_groups_of(num.to_i, fill_with)
-    end
-
-    # splits or iterates over the array in number of groups, padding any remaining slots with fill_with unless it is false
-    def in_groups(array, num, fill_with = nil)
-      array.in_groups(num.to_i)
-    end
-    
-    # returns true if the given object is present in self (that is, if any object == anObject), false otherwise.
-    def include(array, element)
-      array.include? element
-    end
-
-    # return a JSON string representing the model drop (using accepted attributes, methods and named_scopes)
-    # to_include is a list of related drops through associations 
-    def to_json(array, to_include = nil)
-      to_include = to_include.to_sym if to_include      
-      options = { :include => to_include }
-
-      array.to_json(options)
-    end
-
-    # escape url
-    def url_escape(input)
-      CGI.escape(input) rescue input
-    end
-
-    # returns a new array containing self’s elements in reverse order.
-    def reverse(array)
-      array.reverse
-    end
-
-    # decodes html entities
-    def decode_html_entities(string)
-      coder = HTMLEntities.new
-      coder.decode(string)
-    end
-
-    # divides str into substrings based on a delimiter, returning an array of these substrings.
-    def split(string, delimetr)
-      string.split(delimetr)
-    end
-
-    # returns a copy of self with all nil elements removed.
-    def compact(array)
-      array.compact
-    end
-    
-    # concatenates two arrays
-    def concat(array1, array2)
-      array1 + array2
-    end
-    
-    def even(input)
-      (input % 2) == 0
-    end
-    
-    def odd(input)
-      (input % 2) == 1
-    end
-    
-  end
-   
-  Template.register_filter(StandardFilters)
-end