aspen-cli 0.1.2

data/lib/aspen/errors.rb

@@ -0,0 +1,158 @@
+module Aspen
+
+  class Error          < StandardError ; end
+
+  class ArgumentError  < Error ; end
+
+  class LexError       < Error ; end
+  class ParseError     < Error ; end
+  class CompileError   < Error ; end
+  class MatchError     < Error ; end
+
+  class AttributeCollisionError < Error ; end
+
+  class Errors
+    def self.messages(lookup, *args)
+      _messages[lookup].call(args)
+    end
+
+    private
+
+    def self._messages
+      {
+        unexpected_token: -> (args) {
+          <<~ERROR
+            Within state :#{args.last}, unexpected token "#{args.first.peek(1)}" at position #{args.first.pos}.
+            Next 30 characters: #{args.first.peek(30).inspect}
+          ERROR
+        },
+        default_already_registered: -> (args) {
+          <<~ERROR
+            You have already set a default label and attribute name for unlabeled nodes.
+              # TODO List them
+
+            Your configuration is trying to set a second set:
+              # TODO List them
+
+            Please edit your configuration so it only has one `default` line. You may, however,
+            use multiple `default_attribute` lines to set defaults for a specific label.
+          ERROR
+        },
+
+        bad_keyword: -> (args) {
+          <<~ERROR
+            Your configuration includes a line that starts with "#{args.first}".
+            This is not a valid configuration option.
+          ERROR
+        },
+
+        expected_match_precedent: -> (args) {
+          <<~ERROR
+            Indented two lines, so expected the last line to be either
+            :MATCH_START or :MATCH_TO, but was: #{args.first}.
+          ERROR
+        },
+
+        need_default_attribute: -> (args) {
+          <<~ERROR
+            I don't know what attribute is supposed to be assigned by default
+            to any node with the label `#{args.first}`.
+
+            To fix this, use `default_attribute`. For example, if the default
+            attribute should be the #{args.first}'s name, write this:
+
+                default_attribute #{args.first}, name
+
+          ERROR
+        },
+
+        no_default_line: -> (args) {
+          <<~ERROR
+            Nothing has been registered as the default node label. Please add
+            a line that indicates which label and attribute name should be applied
+            to unlabeled nodes.
+
+            Example:
+
+              default Person, name
+
+          ERROR
+        },
+
+        no_body_tag: -> (args) {
+          <<~ERROR
+            We couldn't find a match for the following line
+
+              #{args.first}
+
+            among the following patterns
+
+              #{args.last.registry.map(&:pattern).map(&:inspect).join("\n")}
+
+            Every line should either match a custom grammar definition, or
+            start with a node, like:
+
+              (Matt) [knows] (Brianna).
+
+          ERROR
+        },
+
+        no_config_tag: -> (args) {
+          <<~ERROR
+            There's no configuration option that matches the line:
+
+              #{args.first}
+
+            Maybe it's a spelling error?
+
+          ERROR
+        },
+
+        no_grammar_match: -> (args) {
+          <<~ERROR
+            Expected pattern:
+
+              #{pattern}
+
+            to match
+
+              #{str}
+          ERROR
+        },
+
+        no_statement_tag: -> (args) {
+          <<~ERROR
+            Couldn't figure out how to tag '#{args.first}'."
+          ERROR
+        },
+
+        statement_node_count: -> (args) {
+          <<~ERROR
+            A statement must have exactly two nodes, but we found #{args.first.count} in this statement:
+
+              #{args.last}
+
+            The nodes are:
+
+              #{args.first.map(&:last).join(", ").inspect}
+
+          ERROR
+        },
+
+        statement_edge_count: -> (args) {
+          <<~ERROR
+            A statement must have exactly one edge, but we found #{args.first.count} in this statement:
+
+              #{args.last}
+
+            The edges are:
+
+              #{args.first.map(&:last).join(", ").inspect}
+
+          ERROR
+        },
+
+      }
+    end
+  end
+end

data/lib/aspen/helpers.rb

@@ -0,0 +1,17 @@
+module Aspen
+  module Helpers
+    def node(*args)
+      if args.first.is_a? Hash
+        h = args.first
+        "(#{h.keys.first}: #{h.values.first})"
+      else
+        "not hash"
+        "(#{args.first})"
+      end
+    end
+
+    def edge(name)
+      "[#{name}]"
+    end
+  end
+end

data/lib/aspen/lexer.rb

@@ -0,0 +1,195 @@
+require 'strscan'
+
+module Aspen
+  class Lexer
+
+    STRING_CAPTURE    = /(["'])(?:(?=(\\?))\2.)*?\1/
+    # From https://stackoverflow.com/questions/171480/regex-grabbing-values-between-quotation-marks
+
+    NUMBER_CAPTURE    = /([\d,]+\.?\d+)/
+
+    PASCAL_CASE       = /^([A-Z][a-zA-Z0-9]+)/
+    LABEL_PASCAL_CASE = /^(:[A-Z][a-zA-Z0-9]+)/
+
+    CONTENT_REGEX     = /[[[:alnum:]][[:blank:]]"'&_,\-\–\—\!\.\/\\\?\$]+/
+    LABELED_NODE      = /^([A-Z][a-zA-Z0-9]+): (#{CONTENT_REGEX})\)/
+
+    def self.tokenize(code, env={})
+      new.tokenize(code, env)
+    end
+
+    def tokenize(code, env={})
+      scanner = StringScanner.new(code)
+      tokens = []
+
+      environment = Discourse.assert(env)
+      grammar = environment.grammar
+
+      until scanner.eos?
+        # puts "tokens (6): #{tokens.last(6).inspect}"
+        # puts "\n(#{state}) stack: #{stack}"
+        # puts "grammar: #{grammar.inspect}"
+
+        # Match custom grammars
+        if grammar && scanner.beginning_of_line?
+          line = scanner.scan(/^.*$/)
+          if grammar.match?(line)
+            tokens << [:CUSTOM_GRAMMAR_STATEMENT, line]
+            next
+          else
+            scanner.unscan # reset pointer to beginning of line
+          end
+        end
+
+        # If the line ends with :, it's starting a list.
+        if scanner.beginning_of_line?
+          line = scanner.scan(/^.*$/)
+          if line.match? /:$/
+            tokens << [:PREPARE_START_LIST]
+          end
+          scanner.unscan
+        end
+
+        # Standard Aspen syntax
+        case state
+        when :default then
+          if scanner.scan(/\(/)
+            tokens << [:OPEN_PARENS]
+            push_state :node
+          elsif scanner.scan(/\[/)
+            tokens << [:OPEN_BRACKETS]
+            push_state :edge
+          elsif scanner.scan(/(:\s*\n)/) # Colon, any whitespace, newline
+            tokens << [:START_LIST, scanner.matched]
+            push_state :list
+          elsif scanner.scan(/\./)
+            tokens << [:END_STATEMENT, scanner.matched]
+          elsif scanner.scan(/\s/)
+            # NO OP
+          elsif scanner.scan(/#.*$/)
+            tokens << [:COMMENT, scanner.matched.gsub(/#\s*/, '')]
+          else
+            no_match(scanner, state)
+          end
+
+        when :node then
+          # Removed Cypher form for now. Un   comment the next 3 lines
+          # to start working on it.
+          #
+          # if scanner.scan(LABEL_PASCAL_CASE)
+          #   tokens << [:LABEL, scanner.matched]
+          #   push_state :hash
+          if scanner.match?(LABELED_NODE)
+            push_state :node_labeled
+          elsif scanner.scan(/\n/) && stack == [:list, :node]
+            # If we're inside a list node and we encounter a newline,
+            # pop :node so we can return to the :list state.
+            scanner.unscan
+            pop_state
+          elsif scanner.scan(CONTENT_REGEX)
+            tokens << [:CONTENT, scanner.matched.strip]
+          elsif scanner.scan(/[\:]/)
+            tokens << [:SEPARATOR, scanner.matched]
+          elsif scanner.scan(/\(/)
+            tokens << [:OPEN_PARENS]
+            push_state :label
+          elsif scanner.scan(/\)/)
+            tokens << [:CLOSE_PARENS]
+            pop_state
+          else
+            no_match(scanner, state)
+          end
+
+        when :node_labeled
+          if scanner.scan(PASCAL_CASE)
+            tokens << [:LABEL, scanner.matched]
+            pop_state # Back to Node
+          else
+            no_match(scanner, state)
+          end
+
+        when :edge then
+          if scanner.scan(/[[[:alpha:]]\s]+/)
+            tokens << [:CONTENT, scanner.matched.strip]
+          elsif scanner.scan(/\]/)
+            tokens << [:CLOSE_BRACKETS]
+            pop_state
+          else
+            no_match(scanner, state)
+          end
+
+        when :hash then
+          if scanner.scan(/\{/)
+            tokens << [:OPEN_BRACES]
+          elsif scanner.scan(/[[[:alpha:]]_]+/)
+            tokens << [:IDENTIFIER, scanner.matched]
+          elsif scanner.scan(/[\,\:]/)
+            tokens << [:SEPARATOR, scanner.matched]
+          elsif scanner.scan(STRING_CAPTURE)
+            tokens << [:STRING, scanner.matched]
+          elsif scanner.scan(NUMBER_CAPTURE)
+            tokens << [:NUMBER, scanner.matched]
+          elsif scanner.scan(/\}/)
+            tokens << [:CLOSE_BRACES]
+            pop_state
+          elsif scanner.scan(/\s+/)
+            # NO OP
+          else
+            no_match(scanner, state)
+          end
+
+        when :list then
+          if scanner.scan(/([\-\*\+])/) # -, *, or + (any allowed by Markdown)
+            tokens << [:BULLET, scanner.matched]
+            push_state :node
+          elsif scanner.scan(/\n\n/)
+            tokens << [:END_LIST]
+            pop_state
+          elsif scanner.scan(/\s/)
+            # NO OP
+          else
+            no_match(scanner, state)
+          end
+
+        when :label
+          if scanner.scan(PASCAL_CASE)
+            tokens << [:CONTENT, scanner.matched]
+          elsif scanner.peek(1).match?(/\)/)
+            pop_state # Go back to :node and let :node pop state
+          else
+            no_match(scanner, state)
+          end
+
+        else # No state match
+          raise Aspen::LexError, "There is no matcher for state #{state.inspect}."
+        end
+      end
+
+      tokens
+    end
+
+    def stack
+      @stack ||= []
+    end
+
+    def state
+      stack.last || :default
+    end
+
+    def push_state(state)
+      stack.push(state)
+    end
+
+    def pop_state
+      stack.pop
+    end
+
+    private
+
+    def no_match(scanner, state)
+      raise Aspen::LexError,
+              Aspen::Errors.messages(:unexpected_token, scanner, state)
+    end
+
+  end
+end

data/lib/aspen/list.rb

@@ -0,0 +1,19 @@
+module Aspen
+  class List
+
+    REGEX = /\s*,?\s*and\s*/i
+
+    def initialize(array = [])
+      @elements = Array(array)
+    end
+
+    def self.from_text(text)
+      new text.
+            gsub(REGEX, ', ').
+            split(',').
+            map(&:strip)
+
+    end
+  end
+end
+

data/lib/aspen/node.rb

@@ -0,0 +1,53 @@
+require 'active_support/core_ext/string/inflections'
+require 'aspen/statement'
+
+module Aspen
+  class Node
+
+    extend Dry::Monads[:maybe]
+
+    attr_reader :label, :attributes, :nickname
+    attr_writer :nickname
+
+    def initialize(label: , attributes: {})
+      @label      = label
+      @attributes = attributes
+      @nickname   = nickname_from_first_attr_value
+    end
+
+    def nickname_from_first_attr_value
+      "#{@label}-#{@attributes.values.first}".parameterize.underscore
+    end
+
+    def to_cypher
+      if nickname
+        "(#{nickname}:#{label} #{ attribute_string })"
+      else
+        "(#{label} #{ attribute_string })"
+      end
+    end
+
+    def nickname_node
+      "(#{nickname})"
+    end
+
+    def signature
+      "(#{label})"
+    end
+
+    def attribute_string
+      attributes.to_s.
+        gsub(/"(?<token>[[:alpha:]_]+)"=>/, '\k<token>: ').
+        # This puts a single space inside curly braces.
+        gsub(/\{(\s*)/, "{ ").
+        gsub(/(\s*)\}/, " }")
+    end
+
+    def ==(other)
+      label      == other.label &&
+      attributes == other.attributes &&
+      nickname   == other.nickname
+    end
+
+  end
+end

data/lib/aspen/parser.rb

@@ -0,0 +1,183 @@
+require 'active_support/inflector'
+
+module Aspen
+  class Parser < AbstractParser
+
+=begin
+
+  narrative = statements;
+  statements = { statement }
+  statement = COMMENT | CUSTOM_STATEMENT | list_statement | vanilla_statement
+
+  # Variant 1. TODO: Variant 2
+  list_statement = node, edge, [ list_label ], START_LIST, list_items, END_LIST
+  list_label = OPEN_PARENS, LABEL, CLOSE_PARENS
+  list_items = { list_item }
+  list_item = BULLET, CONTENT, [ list_item_label ]
+  list_item_label = OPEN_PARENS, LABEL, CLOSE_PARENS
+  vanilla_statement = node | node, edge, node, { END_STATEMENT }
+  node = node_short_form | node_grouped_form | node_cypher_form
+  node_short_form = OPEN_PARENS, CONTENT, CLOSE_PARENS
+  node_grouped_form = OPEN_PARENS, { CONTENT, [ COMMA ] }, CLOSE_PARENS
+  node_cypher_form = OPEN_PARENS, LABEL, OPEN_BRACES, { IDENTIFIER, literal, [ COMMA ] }, CLOSE_BRACES
+  literal = STRING | NUMBER
+  edge = OPEN_BRACKETS, CONTENT, CLOSE_BRACKETS
+
+=end
+
+    def parse
+      Aspen::AST::Nodes::Narrative.new(parse_statements)
+    end
+
+    alias_method :parse_narrative, :parse
+
+    def parse_statements
+      results = []
+
+      # Make sure this returns on empty
+      while result = parse_statement
+        results.push(*result)
+        break if tokens[position].nil?
+      end
+
+      results
+    end
+
+    def parse_statement
+      parse_comment           ||
+      parse_custom_statement  ||
+      parse_list_statement    ||
+      parse_vanilla_statement
+    end
+
+    def parse_comment
+      if comment = expect(:COMMENT)
+        Aspen::AST::Nodes::Comment.new(comment.first.last)
+      end
+    end
+
+    def parse_custom_statement
+      if content = expect(:CUSTOM_GRAMMAR_STATEMENT)
+        # FIXME: Why does this need a #first and a #last?
+        # Seems unnecessarily nested. Maybe this happened in the lexer.
+        Aspen::AST::Nodes::CustomStatement.new(content.first.last)
+      end
+    end
+
+    def parse_list_statement
+      if expect(:PREPARE_START_LIST)
+        origin  = parse_node
+        edge    = parse_edge
+        label   = parse_list_label
+        targets = parse_list_items
+        expect(:END_LIST)
+        targets.map do |target|
+          # puts "TARGET #{target.attribute.content.inner_content} had label #{target.label.content.inner_content.inspect}"
+          target.label = label if target.label.content.inner_content.nil?
+          # puts "TARGET #{target.attribute.content.inner_content} has label #{target.label.content.inner_content.inspect}"
+          Aspen::AST::Nodes::Statement.new(origin: origin, edge: edge, target: target)
+        end
+      end
+    end
+
+    def parse_list_label
+      if (_, plural_label, _  = expect(:OPEN_PARENS, :CONTENT, :CLOSE_PARENS))
+        # If singularizing should be conditional, we need to introduce the env in the parser.
+        return plural_label.last.singularize
+      end
+    end
+
+    def parse_list_items
+      if need(:START_LIST)
+        results = []
+        while target = parse_list_item
+          results << target
+        end
+        results
+      end
+    end
+
+    def parse_list_item
+      node = nil
+      if (_, content = expect(:BULLET, :CONTENT))
+        node = Aspen::AST::Nodes::Node.new(attribute: content.last)
+      end
+      if (label = parse_list_item_label)
+        node.label = label
+      end
+      return node
+    end
+
+    def parse_list_item_label
+      if (_, item_label, _  = expect(:OPEN_PARENS, :CONTENT, :CLOSE_PARENS))
+        # If singularizing should be conditional, we need to introduce the env in the parser.
+        return item_label.last
+      end
+    end
+
+
+    def parse_node_labeled_form
+      raise NotImplementedError, "#parse_node_labeled_form not yet implemented"
+    end
+
+    def parse_vanilla_statement
+      # TODO: Might benefit from a condition when doing non-vanilla statements?
+      origin = parse_node
+      edge   = parse_edge
+      target = parse_node
+
+      # SMELL: Nil check
+      advance if peek && peek.first == :END_STATEMENT
+
+      Aspen::AST::Nodes::Statement.new(origin: origin, edge: edge, target: target)
+    end
+
+    def parse_node
+      # parse_node_cypher_form ||
+      parse_node_grouped_form || parse_node_short_form
+    end
+
+    def parse_node_grouped_form
+      if (_, label, sep, content, _ = expect(:OPEN_PARENS, :LABEL, :SEPARATOR, :CONTENT, :CLOSE_PARENS))
+        Aspen::AST::Nodes::Node.new(
+          attribute: content.last,
+          label: label.last
+        )
+      end
+    end
+
+    def parse_node_short_form
+      # Terminal instructions require a "need"
+      _, content, _ = need(:OPEN_PARENS, :CONTENT, :CLOSE_PARENS)
+      Aspen::AST::Nodes::Node.new(
+        attribute: content.last,
+        label: nil
+      )
+    end
+
+    # This complicates things greatly. Can we skip this for now,
+    # by rewriting the tests to get rid of this case, and come back to it?
+    def parse_node_cypher_form
+      if (_, label, _, content, _ = expect(:OPEN_PARENS, :CONTENT, :SEPARATOR, :CONTENT, :CLOSE_PARENS))
+        Aspen::AST::Nodes::Node.new(content: content.last, label: label.last)
+      end
+    end
+
+    def parse_literal
+      raise NotImplementedError, "#parse_literal not yet implemented"
+    end
+
+    def parse_edge
+      if (_, content, _ = expect(:OPEN_BRACKETS, :CONTENT, :CLOSE_BRACKETS))
+        Aspen::AST::Nodes::Edge.new(content.last)
+      end
+    end
+
+    # private
+
+    # def guard(condition)
+    #   return false unless condition
+    # end
+
+  end
+end

data/lib/aspen/renderers/abstract_renderer.rb

@@ -0,0 +1,22 @@
+class AbstractRenderer
+
+  attr_reader :statements, :environment
+
+  def initialize(statements, environment = {})
+    @statements = statements
+    @environment = environment
+  end
+
+  def render
+    raise NotImplementedError, "Find me in #{__FILE__}"
+  end
+
+  def nodes
+    raise NotImplementedError, "Find me in #{__FILE__}"
+  end
+
+  def relationships
+    raise NotImplementedError, "Find me in #{__FILE__}"
+  end
+
+end

data/lib/aspen/renderers/cypher_base_renderer.rb

@@ -0,0 +1,36 @@
+module Aspen
+  module Renderers
+    class CypherBaseRenderer < AbstractRenderer
+
+      def render
+        [
+          nodes(statements),
+          "\n\n",
+          relationships(statements),
+          "\n"
+        ].join()
+      end
+
+      def nodes(input_statements)
+        input_statements.
+          flat_map(&:nodes).
+          map { |node| "MERGE #{node.to_cypher}" }.
+          uniq.
+          join("\n")
+      end
+
+      def relationships(input_statements)
+        input_statements.map do |statement|
+          if statement.type == :custom
+            statement.to_cypher.lines.map { |line| "MERGE #{line}" }.join()
+          elsif statement.type == :vanilla
+            "MERGE #{statement.to_cypher}"
+          else
+            raise ArgumentError, "Statement is the wrong type, expected Aspen::CustomStatemen or Aspen::Statement, but got #{statement.class}"
+          end
+        end.join("\n")
+      end
+
+    end
+  end
+end