scribble 1.0.0

data/lib/scribble/registry.rb

@@ -0,0 +1,95 @@
+module Scribble
+  class Registry
+
+    # Singleton
+
+    def self.method_missing name, *args, &proc
+      instance.send name, *args, &proc
+    end
+
+    def self.instance
+      @instance ||= Registry.new
+    end
+
+    # For class context
+
+    def for *classes, &proc
+      classes.each { |receiver_class| ForClassContext.new(self, receiver_class).instance_eval &proc }
+    end
+
+    class ForClassContext < BasicObject
+      def initialize registry, receiver_class
+        @registry, @receiver_class = registry, receiver_class
+      end
+
+      def method name, *signature, block: false, **options
+        (block ? Block : Method).implement @receiver_class, name, signature, @registry, **options
+      end
+
+      def to_boolean &proc
+        method :to_boolean, to: proc
+      end
+
+      def to_string &proc
+        method :to_string, to: proc
+      end
+
+      def name name
+        @registry.class_name @receiver_class, name
+      end
+    end
+
+    # Class names
+
+    def class_names
+      @class_names ||= {}
+    end
+
+    def class_name receiver_class, name = nil
+      class_names[receiver_class] = name if name
+      class_names[receiver_class] || receiver_class.name.downcase
+    end
+
+    # Methods
+
+    def methods
+      @methods ||= []
+    end
+
+    def unregister name
+      methods.reject! { |method| method.name == name }
+    end
+
+    # Evaluate or cast
+
+    def evaluate name, receiver, args, call = nil, context = nil
+      matcher = Support::Matcher.new self, name, receiver, args
+      matcher.match.new(receiver, call, context).send name, *args
+    end
+
+    def to_boolean receiver
+      evaluate :to_boolean, receiver, []
+    end
+
+    def to_string receiver
+      evaluate :to_string, receiver, []
+    end
+
+    # Split, block
+
+    def split? name
+      method_predicate name, :split?
+    end
+
+    def block? name
+      method_predicate name, :block?
+    end
+
+  private
+
+    def method_predicate name, predicate
+      method = methods.find { |method| method.method_name == name }
+      method && method.send(predicate)
+    end
+  end
+end

data/lib/scribble/support/context.rb

@@ -0,0 +1,98 @@
+module Scribble
+  module Support
+    module Context
+
+      # Registry method shortcut
+
+      module ClassMethods
+        def method *args
+          Scribble::Registry.for(self) { method *args }
+        end
+      end
+
+      def self.included base
+        base.extend ClassMethods
+      end
+
+      # Rendering
+
+      def nodes
+        raise NotImplementedError, 'Class that includes context must implement nodes method'
+      end
+
+      def render nodes: nodes, context: self
+        if !require_conversion?
+          render_without_conversion nodes, context
+
+        elsif converter
+          converter.convert render_without_conversion(nodes, context)
+
+        elsif format.nil?
+          raise "Cannot convert to #{render_format} without format"
+        else
+          raise "No suitable converter converting #{format} to #{render_format}"
+        end
+      end
+
+      def render_without_conversion nodes, context
+        nodes.map { |node| Scribble::Registry.to_string node.evaluate(context) }.join
+      end
+
+      # Template and registers
+
+      def template
+        @context.template
+      end
+
+      def registers
+        @context.registers
+      end
+
+      # Format conversion
+
+      def format
+        @context.format
+      end
+
+      def render_format
+        @context.format
+      end
+
+      def require_conversion?
+        render_format && format != render_format
+      end
+
+      def converter
+        @converter ||= template.find_converter(format, render_format)
+      end
+
+      # Variables
+
+      def variables
+        @variables ||= {}
+      end
+
+      def set_variable name, value
+        variables[name] = value
+      end
+
+      def resolve_variable call
+        variables[call.name] if call.allow_variable
+      end
+
+      # Evaluation
+
+      def evaluate call, args, context
+        resolve_variable(call) || Scribble::Registry.evaluate(call.name, self, args, call, context)
+      rescue Support::Unmatched => local
+        raise local if @context.nil? || call.split?
+
+        begin
+          @context.evaluate call, args, context
+        rescue Support::Unmatched => global
+          raise global.merge(local)
+        end
+      end
+    end
+  end
+end

data/lib/scribble/support/matcher.rb

@@ -0,0 +1,74 @@
+module Scribble
+  module Support
+    class Matcher
+      def initialize registry, name, receiver, args
+        @registry, @name, @receiver, @args = registry, name, receiver, args
+      end
+
+      # Name and receiver matching
+
+      def base_matches
+        @base_matches ||= @registry.methods.select do |method|
+          method.method_name == @name && @receiver.is_a?(method.receiver_class)
+        end
+      end
+
+      # Args cursor helpers
+
+      def step_arg arg_class
+        @cursor += 1 if @cursor < @args.size && @args[@cursor].is_a?(arg_class)
+      end
+
+      def step_args arg_class, max = nil
+        index = 0; while index += 1
+          break unless step_arg arg_class
+          break if max && index == max
+        end
+      end
+
+      # Argument expectations
+
+      def expect arg_class
+        if @max_cursor.nil? || @cursor > @max_cursor
+          @expected, @max_cursor = [], @cursor
+        end
+        if arg_class && @cursor == @max_cursor
+          @expected << @registry.class_name(arg_class)
+        end
+      end
+
+      def unexpected
+        if @max_cursor && @max_cursor < @args.size
+          @registry.class_name @args[@max_cursor].class
+        end
+      end
+
+      # Match a single method
+
+      def match_args method
+        @cursor = 0
+        method.signature.each do |element|
+          if element.is_a? Array
+            step_args *element
+          elsif !step_arg element
+            expect element; return false
+          end
+        end
+        if @cursor < @args.size
+          expect nil; return false
+        end
+        method
+      end
+
+      # Get first match
+
+      def match
+        @match ||= base_matches.select do |method|
+          @args.size >= method.min_arity && (method.max_arity.nil? || @args.size <= method.max_arity)
+        end.select do |method|
+          match_args method
+        end.first || raise(Unmatched.new @base_matches, @expected || [], unexpected, @max_cursor)
+      end
+    end
+  end
+end

data/lib/scribble/support/unmatched.rb

@@ -0,0 +1,70 @@
+module Scribble
+  module Support
+    class Unmatched < Exception
+      def initialize base_matches, expected, unexpected, max_cursor
+        @base_matches, @expected, @unexpected, @max_cursor =
+          base_matches, expected, unexpected, max_cursor
+      end
+
+      # Error message helpers
+
+      def human_arities
+        @base_matches.map do |method|
+          [method.min_arity, method.max_arity]
+        end.uniq.map do |min, max|
+          max ? (min == max ? min.to_s : "#{min}-#{max}") : "#{min}+"
+        end
+      end
+
+      def arg_to call
+        "#{Support::Utilities.ordinalize @max_cursor + 1} argument to '#{call.name}'"
+      end
+
+      def expected_sentence
+        "Expected #{Support::Utilities.to_sentence @expected}"
+      end
+
+      def unexpected_sentence call
+        "got #{@unexpected} #{call.args[@max_cursor].line_and_column}"
+      end
+
+      # To error
+
+      def to_error call
+        if @base_matches.empty?
+          Errors::Undefined.new "Undefined #{'variable or ' if call.allow_variable}"\
+            "method '#{call.name}' #{call.line_and_column}"
+        elsif @expected.empty? && @unexpected.nil?
+          Errors::Arity.new "Wrong number of arguments (#{call.args.size} "\
+            "for #{Support::Utilities.to_sentence human_arities}) "\
+            "for '#{call.name}' #{call.line_and_column}"
+        elsif @expected.empty?
+          Errors::Argument.new "Unexpected #{arg_to call}, #{unexpected_sentence call}"
+        elsif @unexpected.nil?
+          Errors::Argument.new "#{expected_sentence} as #{arg_to call} #{call.line_and_column}"
+        else
+          Errors::Argument.new "#{expected_sentence} as #{arg_to call}, #{unexpected_sentence call}"
+        end
+      end
+
+      # Merge unmatched exceptions to generate merged error
+
+      attr_reader :base_matches, :expected, :unexpected, :max_cursor
+
+      def merge unmatched
+        @base_matches += unmatched.base_matches
+
+        unless @max_cursor.nil?
+          if unmatched.max_cursor > @max_cursor
+            @max_cursor = unmatched.max_cursor
+            @expected   = unmatched.expected
+            @unexpected = unmatched.unexpected
+          elsif unmatched.max_cursor == @max_cursor
+            @expected   += unmatched.expected
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/scribble/support/utilities.rb

@@ -0,0 +1,49 @@
+module Scribble
+  module Support
+    class Utilities
+      class << self
+
+        # String repetition
+
+        def repeat string, count
+          raise Errors::UnlocatedArgument.new("Can't repeat string a negative number of times") if count < 0
+          string * count
+        end
+
+        # String truncation
+
+        def truncate string, on_words, length, omission
+          raise Errors::UnlocatedArgument.new("Can't truncate string with a negative length") if length < 0
+
+          truncated = if on_words
+            string[/(\s*\S*){#{length}}/]
+          else
+            string[0, length]
+          end
+
+          if string != truncated then truncated + omission else string end
+        end
+
+        # Array to sentence
+
+        def to_sentence strings, final_separator = ' or '
+          [strings[0..-2].join(', '), strings[-1].to_s].reject(&:empty?).join(final_separator)
+        end
+
+        # Ordinalize number
+        def ordinalize number
+          if (11..13).include?(number % 100)
+            "#{number}th"
+          else
+            case number % 10
+            when 1; "#{number}st"
+            when 2; "#{number}nd"
+            when 3; "#{number}rd"
+            else    "#{number}th"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scribble/template.rb

@@ -0,0 +1,61 @@
+module Scribble
+  class Template < Partial
+
+    def initialize source, format: nil, loader: nil, converters: []
+      super source, format: format
+      @loader, @converters = loader, converters
+    end
+
+    # Template context
+
+    class Context < Partial::Context
+      def initialize template, registers, variables, render_format
+        @template, @registers, @variables, @render_format = template, registers, variables, render_format
+      end
+
+      def nodes
+        @template.nodes
+      end
+
+      def template
+        @template
+      end
+
+      def registers
+        @registers
+      end
+
+      def format
+        @template.format
+      end
+
+      def render_format
+        @render_format
+      end
+    end
+
+    # Render
+
+    def render variables: {}, registers: {}, format: nil
+      Context.new(self, registers, variables, format).render
+    end
+
+    # Load partial
+
+    def load name, context
+      if @loader
+        if partial = @loader.load(name)
+          Partial::Context.new partial, context
+        end
+      else
+        raise 'Cannot load partial without loader'
+      end
+    end
+
+    # Find converter
+
+    def find_converter from, to
+      @converters.find { |converter| converter.from == from && converter.to == to }
+    end
+  end
+end