scribble 1.0.0

data/lib/scribble/objects/nil.rb

@@ -0,0 +1,21 @@
+module Scribble
+  Registry.for NilClass do
+    name 'nothing'
+
+    to_boolean { false }
+    to_string  { '' }
+
+    # Logical operators
+    method :or,  Object, cast: 'to_boolean'
+    method :and, Object, cast: 'to_boolean'
+
+    # Equality
+    method :equals,  NilClass, returns: true
+    method :differs, NilClass, returns: false
+    method :equals,  Object, returns: false
+    method :differs, Object, returns: true
+
+    # Unary operators
+    method :not, cast: 'to_boolean'
+  end
+end

data/lib/scribble/objects/string.rb

@@ -0,0 +1,62 @@
+module Scribble
+  Registry.for String do
+    to_boolean { !empty? }
+    to_string  { self }
+
+    # Logical operators
+    method :or,  Object, cast: 'to_boolean'
+    method :and, Object, cast: 'to_boolean'
+
+    # Equality
+    method :equals,  String, as: '=='
+    method :differs, String, as: '!='
+    method :equals,  Object, returns: false
+    method :differs, Object, returns: true
+
+    # Unary operators
+    method :not, cast: 'to_boolean'
+
+    # Size and length
+    method :size
+    method :length
+    method :empty, as: 'empty?'
+
+    # Concatenation
+    method :add,     Fixnum, to: ->(fixnum) { self + fixnum.to_s }
+    method :add,     String, as: '+'
+    method :append,  String, as: '+'
+    method :prepend, String
+
+    # Repetition
+    method :multiply, Fixnum, to: ->(count) { Support::Utilities.repeat self, count }
+    method :repeat,   Fixnum, to: ->(count) { Support::Utilities.repeat self, count }
+
+    # Truncation
+    method :truncate, Fixnum,               to: ->(length)           { Support::Utilities.truncate self, false, length, ' ...' }
+    method :truncate, Fixnum, String,       to: ->(length, omission) { Support::Utilities.truncate self, false, length, omission }
+    method :truncate_words, Fixnum,         to: ->(length)           { Support::Utilities.truncate self, true,  length, ' ...' }
+    method :truncate_words, Fixnum, String, to: ->(length, omission) { Support::Utilities.truncate self, true,  length, omission }
+
+    # Replacement
+    method :replace,       String, String, to: ->(replace, with) { self.gsub replace, with }
+    method :replace_first, String, String, to: ->(replace, with) { self.sub  replace, with }
+
+    # Removal
+    method :subtract,     String, to: ->(remove) { self.gsub remove, '' }
+    method :remove,       String, to: ->(remove) { self.gsub remove, '' }
+    method :remove_first, String, to: ->(remove) { self.sub  remove, '' }
+
+    # Case manipulation
+    method :capitalize
+    method :upcase
+    method :downcase
+
+    # Reversal
+    method :reverse
+
+    # Whitespace removal
+    method :strip
+    method :strip_left,  as: 'lstrip'
+    method :strip_right, as: 'rstrip'
+  end
+end

data/lib/scribble/parsing/nester.rb

@@ -0,0 +1,49 @@
+module Scribble
+  module Parsing
+    class Nester
+      def initialize nodes
+        @nodes = nodes
+      end
+
+      def nodes root = true
+        [].tap do |nodes|
+          while step(root)
+            nodes << node
+            if node.block?
+              @current = node
+              node.nodes = nodes false
+            end
+          end
+        end
+      end
+
+    private
+
+      def step root
+        @cursor = @cursor ? @cursor + 1 : 0
+
+        if node.is_a? Nodes::Ending
+          raise unexpected_end if root
+          false
+        elsif node.nil?
+          raise unexpected_eot unless root
+          false
+        else
+          true
+        end
+      end
+
+      def node
+        @nodes[@cursor]
+      end
+
+      def unexpected_end
+        Errors::Syntax.new "Unexpected 'end' #{node.line_and_column}; no block currently open"
+      end
+
+      def unexpected_eot
+        Errors::Syntax.new "Unexpected end of template; unclosed '#{@current.name}' block #{@current.line_and_column}"
+      end
+    end
+  end
+end

data/lib/scribble/parsing/parser.rb

@@ -0,0 +1,132 @@
+require 'parslet'
+
+module Scribble
+  module Parsing
+    class DelimitedChunk < Parslet::Atoms::Base
+      def initialize delimiters, min_chars = 0
+        @delimiters = delimiters
+        @min_chars = min_chars
+      end
+
+      def try(source, context, consume_all)
+        excluding_length = @delimiters.map {|d| source.chars_until(d) }.min
+
+        if excluding_length >= @min_chars
+          return succ(source.consume([excluding_length, 100000].min)) # max 100000 character atom, otherwise error in resulting regexp
+        else
+          return context.err(self, source, "No such string in input: #{@delimiters.inspect}.")
+        end
+      end
+
+      def to_s_inner(prec)
+        "until('#{@delimiters.inspect}')"
+      end
+    end
+
+    class Parser < Parslet::Parser
+      root(:template)
+
+      # Text, tags and endings
+      rule(:template)             { (text | ending | tag).repeat.as(:template) }
+      rule(:text)                 { DelimitedChunk.new(['{{'], 1).as(:text) }
+      rule(:ending)               { ltag >> str('end').as(:ending) >> rtag }
+      rule(:tag)                  { ltag >> (operation >> rtag | tag_command | rtag) }
+
+      # Command ending in rtag
+      rule(:tag_command)          { tag_simple_command | (unary >> tag_command_tail).as(:chain) }
+      rule(:tag_command_tail)     { dot >> (tag_simple_command.repeat(1,1) | simple_function >> tag_command_tail) }
+      rule(:tag_simple_command)   { (name >> space >> tag_args).as(:call) }
+
+      # Command ending in rparen
+      rule(:paren_command)        { paren_simple_command | (unary >> paren_command_tail).as(:chain) }
+      rule(:paren_command_tail)   { dot >> (paren_simple_command.repeat(1,1) | simple_function >> paren_command_tail) }
+      rule(:paren_simple_command) { (name >> space >> paren_args).as(:call) }
+
+      # Entry point to operations
+      rule(:operation)            { logical_or }
+
+      # Or / and
+      rule(:logical_or)           { (logical_and >> ((pipe.as(:op) >> logical_and.as(:arg)).as(:or)).repeat(1)).as(:chain) | logical_and }
+      rule(:logical_and)          { (equality >> ((ampersand.as(:op) >> equality.as(:arg)).as(:and)).repeat(1)).as(:chain) | equality }
+
+      # Equality / inequality
+      rule(:equality)             { (comparison >> (equals | differs).repeat(1)).as(:chain) | comparison }
+      rule(:equals)               { (equals_sign.as(:op) >> comparison.as(:arg)).as(:equals) }
+      rule(:differs)              { (bang_equals.as(:op) >> comparison.as(:arg)).as(:differs) }
+
+      # Comparisons
+      rule(:comparison)           { (additive >> (greater | less | greater_or_equal | less_or_equal).repeat(1)).as(:chain) | additive }
+      rule(:greater)              { (rangle.as(:op) >> additive.as(:arg)).as(:greater) }
+      rule(:less)                 { (langle.as(:op) >> additive.as(:arg)).as(:less) }
+      rule(:greater_or_equal)     { (rangle_equals.as(:op) >> additive.as(:arg)).as(:greater_or_equal) }
+      rule(:less_or_equal)        { (langle_equals.as(:op) >> additive.as(:arg)).as(:less_or_equal) }
+
+      # Add / subtract
+      rule(:additive)             { (multitive >> (add | subtract).repeat(1)).as(:chain) | multitive }
+      rule(:add)                  { (plus.as(:op) >> multitive.as(:arg)).as(:add) }
+      rule(:subtract)             { (dash.as(:op) >> multitive.as(:arg)).as(:subtract) }
+
+      # Multiply / divide
+      rule(:multitive)            { (function >> (multiply | divide | remainder).repeat(1)).as(:chain) | function }
+      rule(:multiply)             { (asterisk.as(:op) >> function.as(:arg)).as(:multiply) }
+      rule(:divide)               { (slash.as(:op) >> function.as(:arg)).as(:divide) }
+      rule(:remainder)            { (percent.as(:op) >> function.as(:arg)).as(:remainder) }
+
+      # Functions
+      rule(:function)             { (unary >> (dot >> simple_function).repeat(1)).as(:chain) | unary }
+      rule(:simple_function)      { (name >> lparen >> (rparen | paren_args)).as(:call) | (name >> space?).as(:call_or_variable) }
+
+      # Unary operators
+      rule(:unary)                { unary_operand | unary_negative | unary_not }
+      rule(:unary_negative)       { (dash.as(:op) >> unary.as(:receiver)).as(:negative) }
+      rule(:unary_not)            { (bang.as(:op) >> unary.as(:receiver)).as(:not) }
+
+      # Unary operand
+      rule(:unary_operand)        { value >> space? | parentheses | simple_function }
+      rule(:parentheses)          { lparen >> (operation >> rparen | paren_command) }
+
+      # Values
+      rule(:value)                { str('true').as(:true) | str('false').as(:false) | empty_string | string | number }
+      rule(:string)               { str("'") >> (str("\\") >> any | str("'").absent? >> any).repeat(1).as(:string) >> str("'") }
+      rule(:empty_string)         { str("'") >> str('').as(:string) >> str("'") }
+      rule(:number)               { match['0-9'].repeat(1).as(:number) }
+
+      # Name and arguments
+      rule(:name)                 { (match['a-z'] >> match['a-z0-9_'].repeat >> match['?!'].maybe).as(:name) }
+      rule(:paren_args)           { (operation >> (comma >> operation).repeat >> rparen | paren_command).as(:args) }
+      rule(:tag_args)             { (operation >> (comma >> operation).repeat >> rtag | tag_command).as(:args) }
+
+      # Spaces
+      rule(:space)                { match('\s').repeat(1) }
+      rule(:space?)               { space.maybe }
+
+      # Tag delimiters
+      rule(:ltag)                 { str('{{') >> space? }
+      rule(:rtag)                 { space? >> str('}}') }
+
+      # Parens
+      rule(:lparen)               { str('(')  >> space? }
+      rule(:rparen)               { str(')')  >> space? }
+
+      # Dot, comma
+      rule(:comma)                { str(',')  >> space? }
+      rule(:dot)                  { str('.') }
+
+      # Operators
+      rule(:pipe)                 { str('|')  >> space? }
+      rule(:ampersand)            { str('&')  >> space? }
+      rule(:equals_sign)          { str('=')  >> space? }
+      rule(:bang_equals)          { str('!=') >> space? }
+      rule(:langle)               { str('<')  >> space? }
+      rule(:rangle)               { str('>')  >> space? }
+      rule(:langle_equals)        { str('<=') >> space? }
+      rule(:rangle_equals)        { str('>=') >> space? }
+      rule(:plus)                 { str('+')  >> space? }
+      rule(:dash)                 { str('-')  >> space? }
+      rule(:asterisk)             { str('*')  >> space? }
+      rule(:slash)                { str('/')  >> space? }
+      rule(:percent)              { str('%')  >> space? }
+      rule(:bang)                 { str('!')  >> space? }
+    end
+  end
+end

data/lib/scribble/parsing/reporter.rb

@@ -0,0 +1,71 @@
+module Scribble
+  module Parsing
+    class Reporter
+      Cause = Struct.new :source, :position do
+        def strings
+          @strings ||= []
+        end
+
+        def raise
+          Kernel.raise Errors::Syntax.new "#{unexpected} at line #{line} column #{column}#{explanation}"
+        end
+
+        def unexpected
+          if character
+            "Unexpected '#{character}'"
+          else
+            "Unexpected end of template"
+          end
+        end
+
+        def character
+          source.instance_variable_get(:@str).string[position]
+        end
+
+        def line
+          source.line_and_column(position).first
+        end
+
+        def column
+          source.line_and_column(position).last
+        end
+
+        def explanation
+          if unterminated_string?
+            "; unterminated string"
+          else
+            ", expected #{Support::Utilities.to_sentence expected}"
+          end
+        end
+
+        def unterminated_string?
+          strings.all? { |string| ["\\", "'"].include? string }
+        end
+
+        def expected
+          strings.map do |string|
+            if    string == 'true' then "a value"
+            elsif string == '+'    then "an operator"
+            elsif string == '('    then "'('"
+            elsif string == '}}'   then "'}}'"
+            elsif string == 'end'  then "'end'"
+            end
+          end.compact.uniq.sort
+        end
+      end
+
+      def err atom, source, message, children = nil
+        err_at atom, source, message, source.pos, children
+      end
+
+      def err_at atom, source, message, position, children = nil
+        if @position.nil? || position > @position
+          @position = position
+          @cause = Cause.new source, position
+        end
+        @cause.strings << atom.str if position == @position && atom.respond_to?(:str)
+        @cause
+      end
+    end
+  end
+end

data/lib/scribble/parsing/transform.rb

@@ -0,0 +1,87 @@
+require 'parslet'
+
+module Scribble
+  module Parsing
+    class Transform < Parslet::Transform
+
+      # Template, text and endings
+
+      rule template: sequence(:nodes) do
+        Nester.new nodes
+      end
+
+      rule text: simple(:slice) do
+        Nodes::Value.new slice, slice.to_s
+      end
+
+      rule ending: simple(:slice) do
+        Nodes::Ending.new slice
+      end
+
+      # Binary operators
+
+      %i(or and equals differs
+         greater less greater_or_equal less_or_equal
+         add subtract multiply divide remainder
+      ).each do |operator|
+        rule operator => {op: simple(:slice), arg: simple(:arg)} do
+          Nodes::Call.new slice, operator, args: [arg]
+        end
+      end
+
+      # Unary operators
+
+      %i(negative not).each do |operator|
+        rule operator => {op: simple(:slice), receiver: simple(:receiver)} do
+          Nodes::Call.new slice, operator, receiver: receiver
+        end
+      end
+
+      # Left associative operation reduction
+
+      rule chain: sequence(:calls) do
+        calls.reduce calls.shift do |base, call|
+          call.receiver = base; call
+        end
+      end
+
+      # Calls with no, one or multiple arguments
+
+      rule call: {name: simple(:slice)} do
+        Nodes::Call.new slice, slice.to_sym
+      end
+
+      rule call: {name: simple(:slice), args: simple(:arg)} do
+        Nodes::Call.new slice, slice.to_sym, args: [arg]
+      end
+
+      rule call: {name: simple(:slice), args: sequence(:args)} do
+        Nodes::Call.new slice, slice.to_sym, args: args
+      end
+
+      # Call without arguments or parentheses
+
+      rule call_or_variable: {name: simple(:slice)} do
+        Nodes::Call.new slice, slice.to_sym, allow_variable: true
+      end
+
+      # Values
+
+      rule number: simple(:slice) do
+        Nodes::Value.new slice, slice.to_i
+      end
+
+      rule string: simple(:slice) do
+        Nodes::Value.new slice, slice.to_s.gsub(/\\(.)/, '\1')
+      end
+
+      rule true: simple(:slice) do
+        Nodes::Value.new slice, true
+      end
+
+      rule false: simple(:slice) do
+        Nodes::Value.new slice, false
+      end
+    end
+  end
+end

data/lib/scribble/partial.rb

@@ -0,0 +1,41 @@
+module Scribble
+  class Partial
+    attr_reader :format
+
+    def initialize source, format: nil
+      @source, @format = source, format
+    end
+
+    # Parse and transform
+
+    def parse
+      @parse ||= Parsing::Parser.new.parse @source, reporter: Parsing::Reporter.new
+    end
+
+    def transform
+      @transform ||= Parsing::Transform.new.apply parse
+    end
+
+    def nodes
+      @nodes ||= transform.nodes
+    end
+
+    # Partial context
+
+    class Context
+      include Support::Context
+
+      def initialize partial, context
+        @partial, @context = partial, context
+      end
+
+      def nodes
+        @partial.nodes
+      end
+
+      def format
+        @partial.format || @context.format
+      end
+    end
+  end
+end