scribble 1.0.0

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/scribble.rb

@@ -0,0 +1,44 @@
+# Support
+
+require_relative 'scribble/support/context'
+require_relative 'scribble/support/utilities'
+require_relative 'scribble/support/matcher'
+require_relative 'scribble/support/unmatched'
+
+# Parsing
+
+require_relative 'scribble/parsing/parser'
+require_relative 'scribble/parsing/transform'
+require_relative 'scribble/parsing/nester'
+require_relative 'scribble/parsing/reporter'
+
+# Node types
+
+require_relative 'scribble/nodes/node'
+require_relative 'scribble/nodes/call'
+require_relative 'scribble/nodes/ending'
+require_relative 'scribble/nodes/value'
+
+# Main components
+
+require_relative 'scribble/registry'
+require_relative 'scribble/method'
+require_relative 'scribble/block'
+require_relative 'scribble/partial'
+require_relative 'scribble/template'
+require_relative 'scribble/errors'
+require_relative 'scribble/converter'
+
+# Object registrations
+
+require_relative 'scribble/objects/boolean'
+require_relative 'scribble/objects/fixnum'
+require_relative 'scribble/objects/nil'
+require_relative 'scribble/objects/string'
+
+# Method registrations
+
+require_relative 'scribble/methods/if'
+require_relative 'scribble/methods/layout'
+require_relative 'scribble/methods/partial'
+require_relative 'scribble/methods/times'

data/lib/scribble/block.rb

@@ -0,0 +1,25 @@
+module Scribble
+  class Block < Method
+    include Support::Context
+
+    def self.block?
+      true
+    end
+
+    def nodes
+      @nodes || @call.nodes
+    end
+
+    def split_nodes
+      nodes.take_while.with_index do |node, index|
+        if node.split?
+          @nodes = nodes.drop index + 1
+          node.evaluate self, allow_split: true, allow_block: false
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/scribble/converter.rb

@@ -0,0 +1,10 @@
+module Scribble
+  def self.converter from_to, &block
+    Object.new.tap do |converter|
+      converter.define_singleton_method(:from) { from_to.keys.first }
+      converter.define_singleton_method(:to)   { from_to.values.first }
+
+      converter.define_singleton_method :convert, &block
+    end
+  end
+end

data/lib/scribble/errors.rb

@@ -0,0 +1,24 @@
+module Scribble
+  module Errors
+    class Error < RuntimeError
+    end
+
+    class Syntax < Error
+    end
+
+    class Undefined < Error
+    end
+
+    class Arity < Error
+    end
+
+    class Argument < Error
+    end
+
+    class UnlocatedArgument < Error
+    end
+
+    class NotFound < Error
+    end
+  end
+end

data/lib/scribble/method.rb

@@ -0,0 +1,91 @@
+module Scribble
+  class Method
+    def initialize receiver, call, context
+      @receiver, @call, @context = receiver, call, context
+    end
+
+    class << self
+      attr_reader :method_name, :receiver_class, :signature
+
+      # Setup instance variables
+
+      def setup receiver_class, method_name, signature
+        raise "Method name needs to be a Symbol, got #{method_name.inspect}" unless method_name.is_a?(Symbol)
+        @receiver_class, @method_name, @signature = receiver_class, method_name, signature
+      end
+
+      # Insert method into a registry
+
+      def eql? other
+        receiver_class == other.receiver_class && method_name == other.method_name && signature == other.signature
+      end
+
+      def insert registry
+        raise "Duplicate method #{method_name} on #{receiver_class}"            if registry.methods.any? { |method| eql? method }
+        raise "Method #{method_name} must be a #{'non-' if split?}split method" unless [nil, split?].include? registry.split?(method_name)
+        raise "Method #{method_name} must be a #{'non-' if block?}block method" unless [nil, block?].include? registry.block?(method_name)
+        registry.methods << self
+      end
+
+      # Setup method and insert into default registry
+
+      def register method_name, *signature, on: Template::Context
+        setup  on, method_name, signature
+        insert Registry.instance
+      end
+
+      # Subclass, setup and insert into registry
+
+      def implement receiver_class, method_name, signature, registry, as: nil, to: nil, cast: nil, returns: nil, split: nil
+        Class.new(self) do
+          setup receiver_class, method_name, signature
+
+          raise "Received multiple implementation options for method"     unless [as, to, cast, returns].compact.size <= 1
+          raise "Method option :as requires String, got #{as.inspect}"    unless as.nil? || as.is_a?(String)
+          raise "Method option :to requires Proc, got #{to.inspect}"      unless to.nil? || to.is_a?(Proc)
+          raise "Method option :cast must be 'to_boolean' or 'to_string'" unless [nil, 'to_boolean', 'to_string'].include? cast
+          raise "Method option :split must be true"                       unless [nil, true].include? split
+
+          # Redefine split?
+          define_singleton_method :split? do
+            true
+          end if split
+
+          # Implement method
+          send :define_method, method_name do |*args|
+            if to
+              @receiver.instance_exec *args, &to
+            elsif cast
+              registry.evaluate method_name, registry.send(cast, @receiver), args, @call, @context
+            elsif !returns.nil?
+              returns
+            else
+              @receiver.send (as || method_name), *args
+            end
+          end
+        end.insert registry
+      end
+
+      # Default split and block
+
+      def split?; false; end
+      def block?; false; end
+
+      # Arity
+
+      def min_arity
+        @min_arity ||= signature.reduce 0 do |min_arity, element|
+          element.is_a?(Array) ? min_arity : min_arity + 1
+        end
+      end
+
+      def max_arity
+        @max_arity ||= signature.reduce 0 do |max_arity, element|
+          if max_arity
+            element.is_a?(Array) ? element[1] && max_arity + element[1] : max_arity + 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scribble/methods/if.rb

@@ -0,0 +1,26 @@
+module Scribble
+  module Methods
+    class If < Block
+      register :if, Object
+
+      def if object
+        @paths = []
+        send :elsif, object
+
+        render(nodes: @paths.map { |condition, nodes| nodes if condition }.compact.first || [])
+      end
+
+      method :elsif, Object, split: true
+
+      def elsif object
+        @paths.unshift [Registry.to_boolean(object), split_nodes]
+      end
+
+      method :else, split: true
+
+      def else
+        @paths.unshift [true, nodes]
+      end
+    end
+  end
+end

data/lib/scribble/methods/layout.rb

@@ -0,0 +1,25 @@
+module Scribble
+  module Methods
+    class Layout < Block
+      register :layout, String, [Object, 1]
+
+      def layout name, object = nil
+        template.load(name, self).tap do |partial_context|
+          raise Errors::NotFound.new("Layout partial '#{name}' not found #{@call.line_and_column}") if partial_context.nil?
+          partial_context.set_variable name.to_sym, object if object
+          @render_format = partial_context.format
+        end.render
+      end
+
+      method :content
+
+      def content
+        render context: @context
+      end
+
+      def render_format
+        @render_format || super
+      end
+    end
+  end
+end

data/lib/scribble/methods/partial.rb

@@ -0,0 +1,14 @@
+module Scribble
+  module Methods
+    class Partial < Method
+      register :partial, String, [Object, 1]
+
+      def partial name, object = nil
+        @context.template.load(name, @context).tap do |partial_context|
+          raise Errors::NotFound.new("Partial '#{name}' not found #{@call.line_and_column}") if partial_context.nil?
+          partial_context.set_variable name.to_sym, object if object
+        end.render
+      end
+    end
+  end
+end

data/lib/scribble/methods/times.rb

@@ -0,0 +1,11 @@
+module Scribble
+  module Methods
+    class Times < Block
+      register :times, on: Fixnum
+
+      def times
+        render * @receiver
+      end
+    end
+  end
+end

data/lib/scribble/nodes/call.rb

@@ -0,0 +1,55 @@
+module Scribble
+  module Nodes
+    class Call < Node
+      attr_reader :name, :args, :allow_variable
+
+      attr_accessor :receiver, :nodes
+
+      def initialize slice, name, args: [], receiver: nil, allow_variable: false
+        super slice
+        @name, @args, @receiver, @allow_variable = name, args, receiver, allow_variable
+      end
+
+      def evaluate context, allow_block: true, allow_split: false
+        disallow_split unless allow_split
+        disallow_block unless allow_block
+
+        if @receiver
+          Registry.evaluate @name, evaluated_receiver(context), evaluated_args(context), self, context
+        else
+          context.evaluate self, evaluated_args(context), context
+        end
+      rescue Errors::UnlocatedArgument => e
+        raise Errors::Argument.new("#{e.message} #{line_and_column}")
+      rescue Support::Unmatched => e
+        raise e.to_error self
+      end
+
+      def block?
+        Registry.block? name
+      end
+
+      def split?
+        Registry.split? name
+      end
+
+    private
+
+      def disallow_split
+        raise Errors::Syntax.new "Unexpected '#{name}' #{line_and_column}" if split?
+      end
+
+      def disallow_block
+        raise Errors::Syntax.new "Unexpected '#{name}' #{line_and_column}; block methods can't be arguments" if block?
+      end
+
+      def evaluated_receiver context
+        @evaluated_receiver ||= @receiver.evaluate context, allow_block: false
+      end
+
+      def evaluated_args context
+        @evaluated_args ||= args.map { |arg| arg.evaluate context, allow_block: false }
+      end
+    end
+  end
+end

data/lib/scribble/nodes/ending.rb

@@ -0,0 +1,6 @@
+module Scribble
+  module Nodes
+    class Ending < Node
+    end
+  end
+end

data/lib/scribble/nodes/node.rb

@@ -0,0 +1,24 @@
+module Scribble
+  module Nodes
+    class Node
+      attr_reader :slice
+
+      def initialize slice
+        @slice = slice
+      end
+
+      def block?
+        false
+      end
+
+      def split?
+        false
+      end
+
+      def line_and_column
+        line, column = slice.line_and_column
+        "at line #{line} column #{column}"
+      end
+    end
+  end
+end

data/lib/scribble/nodes/value.rb

@@ -0,0 +1,16 @@
+module Scribble
+  module Nodes
+    class Value < Node
+      attr_reader :value
+
+      def initialize slice, value
+        super(slice)
+        @value = value
+      end
+
+      def evaluate context, **options
+        @value
+      end
+    end
+  end
+end

data/lib/scribble/objects/boolean.rb

@@ -0,0 +1,33 @@
+module Scribble
+  Registry.for TrueClass do
+    method :equals,  TrueClass,  returns: true
+    method :equals,  FalseClass, returns: false
+    method :differs, TrueClass,  returns: false
+    method :differs, FalseClass, returns: true
+  end
+
+  Registry.for FalseClass do
+    method :equals,  TrueClass,  returns: false
+    method :equals,  FalseClass, returns: true
+    method :differs, TrueClass,  returns: true
+    method :differs, FalseClass, returns: false
+  end
+
+  Registry.for TrueClass, FalseClass do
+    name 'boolean'
+
+    to_boolean { self }
+    to_string  { to_s }
+
+    # Logical operators
+    method :or,  Object, to: ->(object) { self | Scribble::Registry.to_boolean(object) }
+    method :and, Object, to: ->(object) { self & Scribble::Registry.to_boolean(object) }
+
+    # Equality
+    method :equals,  Object, returns: false
+    method :differs, Object, returns: true
+
+    # Unary not
+    method :not, to: -> { !self }
+  end
+end

data/lib/scribble/objects/fixnum.rb

@@ -0,0 +1,53 @@
+module Scribble
+  Registry.for Fixnum do
+    name 'number'
+
+    to_boolean { !zero? }
+    to_string  { to_s }
+
+    # Logical operators
+    method :or,  Object, cast: 'to_boolean'
+    method :and, Object, cast: 'to_boolean'
+
+    # Equality
+    method :equals,  Fixnum, as: '=='
+    method :differs, Fixnum, as: '!='
+    method :equals,  Object, returns: false
+    method :differs, Object, returns: true
+
+    # Comparisons
+    method :greater,          Fixnum, as: '>'
+    method :greater_or_equal, Fixnum, as: '>='
+    method :less,             Fixnum, as: '<'
+    method :less_or_equal,    Fixnum, as: '<='
+
+    # Calculations
+    method :add,       Fixnum, as: '+'
+    method :subtract,  Fixnum, as: '-'
+    method :multiply,  Fixnum, as: '*'
+    method :remainder, Fixnum, as: '%'
+
+    method :divide,    Fixnum, to: ->(n) {
+      begin
+        self / n
+      rescue ZeroDivisionError
+        raise Errors::UnlocatedArgument.new "Division by zero"
+      end
+    }
+
+    # Unary operators
+    method :negative, to: -> { -self }
+    method :not, cast: 'to_boolean'
+
+    # String manipulations
+    method :add,      String, cast: 'to_string'
+    method :multiply, String, to: ->(string) { Support::Utilities.repeat string, self }
+
+    # Unary methods
+    method :abs
+    method :odd,  as: 'odd?'
+    method :even, as: 'even?'
+    method :zero, as: 'zero?'
+    method :nonzero,  to: -> { self != 0 }
+  end
+end