liquor 0.1.1 → 0.9.1

data/lib/liquor/drop/dropable.rb

@@ -0,0 +1,17 @@
+module Liquor
+  module Dropable
+    module ClassMethods
+      def to_drop
+        DropDelegation.wrap_scope(self)
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def to_drop
+      DropDelegation.wrap_element(self)
+    end
+  end
+end

data/lib/liquor/emitter.rb

@@ -0,0 +1,313 @@
+module Liquor
+  class Emitter
+    include ASTTools
+
+    attr_reader :compiler, :context
+
+    def initialize(context)
+      @context  = context
+      @compiler = context.compiler
+      @buffer   = ""
+      @current_capture_var = ""
+    end
+
+    def env
+      '_env'
+    end
+
+    def buf
+      "_buf#{@current_capture_var}"
+    end
+
+    def storage
+      "_storage"
+    end
+
+    def ident(node)
+      name, = nvalue(node)
+
+      case @context.type name
+      when :builtin
+        case name
+        when 'null';  'nil'
+        when 'true';  'true'
+        when 'false'; 'false'
+        end
+      when :variable
+        @context.access name, nloc(node)
+      when :function
+        raise NameError.new("using function `#{name}' as a variable", nloc(node))
+      when :free
+        raise NameError.new("identifier `#{name}' is not bound", nloc(node))
+      end
+    end
+
+    OPERATORS = {
+      :uminus => '-',  :not   => '!',
+      :mul    => '*',  :div   => '/',  :mod => '%',
+      :plus   => '+',  :minus => '-',
+      :eq     => '==', :neq   => '!=',
+      :lt     => '<',  :leq   => '<=',
+      :gt     => '>',  :geq   => '>=',
+      :and    => '&&', :or    => '||',
+    }
+
+    def expr(node)
+      case ntype(node)
+      when :ident
+        ident(node)
+      when :integer
+        integer(node)
+      when :string
+        string(node)
+      when :tuple
+        tuple(node)
+      when :plus
+        plus(node)
+      when :mul, :div, :mod, :minus,
+           :lt, :leq, :gt, :geq
+        integer_binop(node)
+      when :uminus
+        integer_unop(node)
+      when :eq, :neq
+        equality_binop(node)
+      when :and, :or
+        boolean_binop(node)
+      when :not
+        boolean_unop(node)
+      when :index
+        index(node)
+      when :external
+        external(node)
+      when :call
+        call(node)
+      else
+        raise "unknown node #{ntype node}"
+      end
+    end
+
+    def external(node)
+      target, method, args = nvalue(node)
+      name, = nvalue(method)
+
+      if args
+        arg, kw = nvalue(args)
+
+        if arg.nil?
+          out_args = [ "nil" ]
+        else
+          out_args = [ expr(arg) ]
+        end
+
+        kw.each do |kwarg, kwval|
+          out_args << "#{kwarg.inspect} => #{expr(kwval)}"
+        end
+      else
+        out_args = []
+      end
+
+      "#{check_external(target)}.liquor_send(#{name.inspect}, [ #{out_args.join(", ")} ], #{nloc(method).inspect})"
+    end
+
+    def call(node)
+      lhs, rhs = nvalue(node)
+      name,    = nvalue(lhs)
+      arg, kw  = nvalue(rhs)
+
+      if !@context.function? name
+        raise NameError.new("undefined function `#{name}'", nloc(lhs))
+      end
+
+      function = @context.compiler.function(name)
+      if function.unnamed_arg && arg.nil?
+        raise ArgumentError.new("unnamed argument is required, but none provided", nloc(rhs))
+      elsif !function.unnamed_arg && !arg.nil?
+        raise ArgumentError.new("unnamed argument is not accepted, but is provided", nloc(arg))
+      else
+        function.mandatory_named_args.each do |kwarg,|
+          unless kw.include? kwarg
+            raise ArgumentError.new("named argument `#{kwarg}' is required, but none provided", nloc(rhs))
+          end
+        end
+        kw.each do |kwarg, kwval|
+          if !function.mandatory_named_args.include?(kwarg) &&
+             !function.optional_named_args.include?(kwarg)
+            raise ArgumentError.new("named argument `#{kwarg}' is not accepted, but is provided", nloc(kwval))
+          end
+        end
+      end
+
+      if arg.nil?
+        args = [ "nil" ]
+      else
+        args = [ expr(arg) ]
+      end
+
+      kw = kw.map do |kwarg, kwval|
+        "#{kwarg.inspect} => #{expr(kwval)}"
+      end
+      args << "{ #{kw.join(", ")} }"
+
+      args << nloc(node).inspect
+
+      "@functions[#{name.inspect}].call(#{args.join(', ')})"
+    end
+
+    def index(node)
+      lhs, rhs = nvalue(node)
+      "#{check_tuple(lhs)}[#{check_integer(rhs)}]"
+    end
+
+    def plus(node)
+      lhs, rhs = nvalue(node)
+      "Runtime.add!(#{expr(lhs)}, #{nloc(lhs).inspect}," +
+        " #{expr(rhs)}, #{nloc(rhs).inspect})"
+    end
+
+    def integer_binop(node)
+      lhs, rhs = nvalue(node)
+      "(#{check_integer(lhs)} #{OPERATORS[ntype(node)]} #{check_integer(rhs)})"
+    end
+
+    def integer_unop(node)
+      expr, = nvalue(node)
+      "#{OPERATORS[ntype(node)]}(#{check_integer(expr)})"
+    end
+
+    def equality_binop(node)
+      lhs, rhs = nvalue(node)
+      "(#{expr(lhs)} #{OPERATORS[ntype(node)]} #{expr(rhs)})"
+    end
+
+    def boolean_binop(node)
+      lhs, rhs = nvalue(node)
+      "(#{convert_boolean(lhs)} #{OPERATORS[ntype(node)]} #{convert_boolean(rhs)})"
+    end
+
+    def boolean_unop(node)
+      expr, = nvalue(node)
+      # converts by itself
+      "#{OPERATORS[ntype(node)]}(#{expr(expr)})"
+    end
+
+    def convert_boolean(node)
+      "!!(#{expr(node)})"
+    end
+
+    def check_integer(node)
+      "Runtime.integer!(#{expr(node)}, #{nloc(node).inspect})"
+    end
+
+    def integer(node)
+      value, = nvalue(node)
+      value
+    end
+
+    def check_string(node)
+      "Runtime.string!(#{expr(node)}, #{nloc(node).inspect})"
+    end
+
+    def string(node)
+      value, = nvalue(node)
+      value.inspect
+    end
+
+    def check_tuple(node)
+      "Runtime.tuple!(#{expr(node)}, #{nloc(node).inspect})"
+    end
+
+    def tuple(node)
+      value, = nvalue(node)
+      code = value.map do |elem|
+        expr elem
+      end.join(", ")
+      "[ #{code} ]"
+    end
+
+    def check_external(node)
+      "Runtime.external!(#{expr(node)}, #{nloc(node).inspect})"
+    end
+
+    def check_interp(node)
+      "Runtime.interp!(#{expr(node)}, #{nloc(node).inspect})"
+    end
+
+    def compile_toplevel(block)
+      compile_block(block)
+
+      [
+        %!lambda { |_env={}, _storage={}|\n!,
+        %|  _buf = ""\n|,
+        ([
+          %|  |,
+          @context.externals.map do |extern|
+            @context.access(extern)
+          end.join(", "),
+          %| = |,
+          @context.externals.map do |extern|
+            %Q|_env[#{extern.inspect}]|
+          end.join(", "),
+        ] if @context.externals.any?),
+        %|\n|,
+        flush!,
+        %|  _buf\n|,
+        %|}\n|
+      ].join
+    end
+
+    def compile_block(block)
+      block.each do |node|
+        case ntype(node)
+        when :plaintext
+          cat! string(node)
+
+        when :interp
+          expr, = nvalue(node)
+          cat! check_interp(expr)
+
+        when :tag
+          ident, args = nvalue(node)
+          name, = nvalue(ident)
+
+          unless @compiler.has_tag? name
+            raise NameError.new("undefined tag `#{name}'", nloc(ident))
+          end
+
+          @compiler.tag(name).compile(self, node)
+
+        else
+          raise "unknown block-level node #{ntype(node)}"
+        end
+      end
+    rescue Liquor::Diagnostic => e
+      @compiler.add_diagnostic e
+    end
+
+    def capture
+      previous_capture_var = @current_capture_var
+      @current_capture_var = @buffer.lines.count.to_s # unique id
+      out! %Q{#{buf} = ""\n}
+
+      yield
+
+      buf
+    ensure
+      @current_capture_var = previous_capture_var
+    end
+
+    def cat!(string)
+      out! "#{buf} << (#{string})\n"
+    end
+
+    def out!(string)
+      string = string.gsub /(^|\n)/m, '\1' + ("  " * @context.nesting)
+      @buffer.concat string
+    end
+
+    def flush!
+      @buffer
+    ensure
+      @buffer = ""
+    end
+  end
+end

data/lib/liquor/extensions/kaminari.rb

@@ -0,0 +1,14 @@
+require 'kaminari/models/array_extension'
+require 'liquor/extensions/pagination'
+
+module Kaminari
+  class PaginatableArray
+    def to_drop
+      Liquor::Pagination::Scope.new(self)
+    end
+
+    def to_page_path(url_generator, page)
+      raise NotImplementedError, "Liquor: Kaminari::PaginatableArray cannot generate page paths"
+    end
+  end
+end

data/lib/liquor/extensions/pagination.rb

@@ -0,0 +1,235 @@
+require 'rails'
+require 'liquor/drop/drop'
+
+module Liquor
+  module Pagination
+    include Library
+
+    # Usage:
+
+=begin
+{% pagination start: %}
+<div class='digg_pagination'>
+  {% if page.is_current then: %}
+  <span class="disabled previous_page">&#8592; Previous</span>
+  {% else %}
+  <a href="{{ previous_page_url }}" rel="previous" class="previous_page_page">&#8592; Previous</a>
+  {% end if %}
+{% page: %}
+  {% if page.is_current then: %}
+  <em class="current">{{ page.number }}</em>
+  {% elsif page.is_next then: %}
+  <a href="{{ page.url }}" rel="next">{{ page.number }}</a>
+  {% elsif page.is_prev then: %}
+  <a href="{{ page.url }}" rel="previous">{{ page.number }}</a>
+  {% else %}
+  <a href="{{ page.url }}">3</a>
+  {% end if %}
+{% gap: %}
+  <span class="gap">&hellip;</span>
+{% end: %}
+  {% if page.is_current then: %}
+  <span class="disabled next_page">Next &#8594;</span>
+  {% else %}
+  <a href="{{ next_page_url }}" rel="next" class="next_page">Next &#8594;</a></div>
+  {% end if %}
+{% end pagination %}
+=end
+
+    class UrlGenerator
+      def self.bootstrap
+        unless @bootstrapped
+          include ::Rails.application.routes.url_helpers
+          @bootstrapped = true
+        end
+
+        self
+      end
+
+      cattr_accessor :default_url_options
+      self.default_url_options = {}
+    end
+
+    class PageExternal
+      include Liquor::External
+
+      def initialize(collection, options={})
+        @collection = collection
+        @options    = options
+        @index      = @collection.current_page
+      end
+
+      def is_current
+        @index == @collection.current_page
+      end
+
+      def is_first
+        @index == 1
+      end
+
+      def is_last
+        @index == @collection.total_pages - 1
+      end
+
+      def is_prev
+        @index == @collection.current_page - 1
+      end
+
+      def is_next
+        @index == @collection.current_page + 1
+      end
+
+      export :is_current, :is_first, :is_last, :is_prev, :is_next
+
+      def in_inner_window
+        (@collection.current_page - @index).abs <= @options[:inner_window]
+      end
+
+      def in_outer_window
+        @index <= @options[:outer_window] ||
+            @collection.total_pages - @index < @options[:outer_window]
+      end
+
+      def is_gap
+        !in_outer_window && !in_inner_window
+      end
+
+      export :in_inner_window, :in_outer_window, :is_gap
+
+      def with(index)
+        @index = index
+        self
+      end
+
+      def each_relevant_page
+        relevant_pages.each do |page|
+          with(page); yield
+        end
+      end
+
+      def relevant_pages
+        left_window_plus_one = 1.upto(@options[:outer_window] + 1).to_a
+        right_window_plus_one = (@collection.total_pages - @options[:outer_window]).upto(@collection.total_pages).to_a
+        inside_window_plus_each_sides = (@collection.current_page - @options[:inner_window] - 1).upto(@collection.current_page + @options[:inner_window] + 1).to_a
+
+        (left_window_plus_one + inside_window_plus_each_sides + right_window_plus_one).uniq.sort.reject {|x| (x < 1) || (x > @collection.total_pages)}
+      end
+
+      def path
+        @url_generator ||= UrlGenerator.bootstrap.new
+
+        if @collection.respond_to? :to_page_path
+          @collection.to_page_path(@url_generator, @index)
+        elsif @collection.is_a? ActiveRecord::Relation
+          @url_generator.polymorphic_path(@collection.klass, page: @index)
+        else
+          raise "Don't know how to generate page path for #{@collection.class}"
+        end
+      end
+      export :path
+    end
+
+    class Scope < Liquor::Drop::Scope
+      def total_entries
+        @source.total_count
+      end
+
+      def per_page(size)
+        @source.per(size).to_drop
+      end
+
+      export :total_entries, :per_page
+    end
+
+    tag "pagination" do |emit, context, node|
+      arg, kw = check_args node,
+          nil,
+          :"start" => :block,
+          :"page"  => :block,
+          :"gap"   => :block,
+          :"end"   => :block
+
+      context.nest do
+        context.declare :page
+
+        options    = context.access(:options)
+        collection = context.access(:collection)
+        page       = context.access(:page)
+
+        emit.out! %Q|#{page} = Liquor::Pagination::PageExternal.new(#{collection}, #{options})\n|
+
+        { :first_page_path => '1',
+          :last_page_path  => "#{collection}.total_pages - 1",
+          :next_page_path  => "#{collection}.current_page + 1",
+          :prev_page_path  => "#{collection}.current_page - 1",
+        }.each do |var, value|
+          context.declare var
+          emit.out! %Q|#{context.access(var)} = #{page}.with(#{value}).path\n|
+        end
+
+        [ :current_page, :total_pages ].each do |var|
+          context.declare var
+          emit.out! %Q|#{context.access(var)} = #{collection}.#{var}\n|
+        end
+
+        emit.out! %Q|#{page}.with(1)\n|
+        emit.compile_block kw[:start]
+
+        emit.out! %Q|#{page}.each_relevant_page do\n|
+        emit.out! %Q|  if #{page}.is_gap\n|
+        emit.compile_block kw[:gap]
+        emit.out! %Q|  else\n|
+        emit.compile_block kw[:page]
+        emit.out! %Q|  end\n|
+        emit.out! %Q|end\n|
+
+        emit.out! %Q|#{page}.with(#{collection}.total_pages - 1)\n|
+        emit.compile_block kw[:end]
+      end
+    end
+
+    # {% paginate posts %}
+
+    tag "paginate" do |emit, context, node|
+      name, collection, *kwargs = nvalue(node)
+      check_arg_type(collection, :expr)
+
+      valid_kws = %w[inner_window outer_window]
+
+      kw = Hash[kwargs.map do |kwarg|
+        check_arg_type(kwarg, :expr)
+
+        name, value = kwname(kwarg), kwvalue(kwarg)
+        if !valid_kws.include?(name)
+          raise SyntaxError.new("unexpected `#{name}', expecting one of #{valid_kws.
+                                 map { |kw| "`#{kw}'" }.join(", ")}", nloc(kwarg))
+        end
+
+        [ name, value ]
+      end]
+
+      context.nest do
+        context.declare :collection
+        emit.out! %Q|#{context.access(:collection)} = #{emit.check_external(collection)}.source\n|
+
+        inner_window = kw[:inner_window] ? emit.check_integer(kw[:inner_window]) : '2'
+        outer_window = kw[:outer_window] ? emit.check_integer(kw[:outer_window]) : '0'
+
+        context.declare :options
+        emit.out! %Q|#{context.access(:options)} = {
+            inner_window: #{inner_window},
+            outer_window: #{outer_window}
+          }\n|
+
+        manager = context.compiler.manager
+
+        source = manager.fetch_partial "_pagination"
+        if source.nil?
+          raise ArgumentError.new("partial `pagination' does not exist", nloc(arg))
+        end
+
+        emit.compile_block source
+      end
+    end
+  end
+end