aspen-cli 0.1.2

data/lib/aspen/custom_grammar/ast.rb

@@ -0,0 +1,13 @@
+module Aspen
+  module CustomGrammar
+    module AST
+      module Nodes
+      end
+    end
+  end
+end
+
+require 'aspen/custom_grammar/ast/nodes/bare'
+require 'aspen/custom_grammar/ast/nodes/capture_segment'
+require 'aspen/custom_grammar/ast/nodes/content'
+require 'aspen/custom_grammar/ast/nodes/expression'

data/lib/aspen/custom_grammar/compiler.rb

@@ -0,0 +1,80 @@
+module Aspen
+  module CustomGrammar
+    class Compiler
+
+      attr_reader :root, :environment
+
+      def self.render(root, environment = {})
+        new(root, environment).render
+      end
+
+      def self.compile(root, environment = {})
+        new(root, environment).compile
+      end
+
+      def initialize(root, environment = {})
+        @root = root
+        @environment = environment
+        @type_registry  = {}
+        @label_registry = {}
+      end
+
+      def compile
+        # Call #render before accessing the registry. If this code
+        # changes, we may need more process control to ensure #render
+        # goes first.
+        {
+          pattern: render,
+          type_registry: @type_registry,
+          label_registry: @label_registry
+        }
+      end
+
+      def render
+        visit(root)
+      end
+
+      def visit(node)
+        short_name = node.class.to_s.split('::').last.downcase
+        method_name = "visit_#{short_name}"
+        # puts "---- #{method_name}"
+        # puts node.inspect
+        send(method_name, node)
+      end
+
+      def visit_expression(node)
+        segments = node.segments.map { |segment| visit(segment) }
+        segments.last.gsub!(/\.$/, '') # Make the last period optional? Maybe?
+        segments.unshift "^"           # Add a bol matcher to the front.
+        segments.push "\\.?$"          # Make the last period optional? Again?
+        Regexp.new(segments.join)
+      end
+
+      def visit_capturesegment(node)
+        value = case node.type
+        when :integer then /(?<#{node.var_name}>[\d,]+\d*)/    # No decimal
+        when :float   then /(?<#{node.var_name}>[\d,]+\.\d+)/  # Decimal point required
+        when :numeric then /(?<#{node.var_name}>[\d,]+\.?\d*)/ # Optional decimal
+        when :string  then /(?<#{node.var_name}>.*?)/
+        when :node    then /(?<#{node.var_name}>.*?)/
+        else
+          raise ArgumentError, "No regexp pattern for type \"#{node.type}\"."
+        end
+        # Add type to type registry
+        @type_registry[node.var_name] = node.type
+        # Add label to label registry
+        @label_registry[node.var_name] = node.label if node.type == :node
+        return value
+      end
+
+      def visit_bare(node)
+        visit(node.content)
+      end
+
+      def visit_content(node)
+        node.content
+      end
+
+    end
+  end
+end

data/lib/aspen/custom_grammar/grammar.rb

@@ -0,0 +1,78 @@
+module Aspen
+  module CustomGrammar
+    class Grammar
+
+      # API Surface:
+      #   #add?
+      #   #match? (Boolean) -> Does the grammar cover this string, match this case?
+      #   #match  (Matcher) -> Request the matcher for this string.
+      #   #compile_pattern (Regexp) -> Given a matcher expression, return the Regexp pattern that can match against a string.
+
+      attr_reader :registry
+
+      include Dry::Monads[:maybe]
+
+      def initialize()
+        @registry = []
+        @slug_counters = Hash.new { 1 }
+      end
+
+      # Does the given text match a matcher?
+      def match?(string)
+        !!match(string)
+      rescue Aspen::Error
+        false
+      end
+
+      def match(text)
+        results = @registry.select { |m| m.match?(text) }
+        warn "Found #{results.count} matches" if results.count > 1
+        # raise Aspen::Error, "No results." if results.empty?
+        return results.first
+      end
+
+      alias_method :matcher_for, :match
+
+      def inspect
+        "#<Aspen::Grammar matchers: #{count}>"
+      end
+
+      def count
+        registry.count
+      end
+
+      def add(maybe_matchers)
+        matchers = Array(maybe_matchers).flatten
+        raise unless matchers.all? { |m| m.is_a? Aspen::CustomGrammar::Matcher }
+        matchers.each { |matcher| @registry << matcher }
+      end
+
+      # This doesn't quite work, because var results is untyped.
+      def render(content)
+        matcher  = matcher_for(content)
+        results  = results_for(content)
+        template = matcher.template
+      end
+
+      def results_for(text)
+        matcher_for(text).captures!(text)
+      end
+
+      def match!(text)
+        unless match(text)
+          raise Aspen::MatchError, <<~ERROR
+            Couldn't find an Aspen grammar that matched the line:
+
+                #{text}
+
+            For more details (if you can), try running this to see all the match patterns:
+
+                Aspen::Grammar.registry.map(&:pattern)
+
+          ERROR
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/custom_grammar/lexer.rb

@@ -0,0 +1,76 @@
+require 'strscan'
+
+module Aspen
+  module CustomGrammar
+    class Lexer
+      def self.tokenize(code, env={})
+        new.tokenize(code, env)
+      end
+
+      def tokenize(code, env={})
+        scanner = StringScanner.new(code)
+        tokens = []
+
+        # puts "tokens: #{tokens} | state: #{state} | stack: #{stack}"
+
+        until scanner.eos?
+          case state
+          when :default then
+            if scanner.scan(/\(/)
+              tokens << [:OPEN_PARENS]
+              push_state :capture_segment
+            elsif scanner.scan(/[[[:alnum:]][[:blank:]]\!"\#$%&'*+,\-.\/:;<=>?@\[\\\]^_‘\{\|\}~]+/)
+              tokens << [:BARE, scanner.matched]
+            else
+              no_match(scanner, state)
+            end
+
+          when :capture_segment
+            if scanner.scan(/\s+/)
+              # NO OP
+            elsif scanner.scan(/^(numeric|integer|float|string)/)
+              tokens << [:TYPE, scanner.matched]
+            elsif scanner.scan(Aspen::Lexer::PASCAL_CASE)
+              tokens << [:TYPE, ["node", scanner.matched]]
+            # TODO: This should only accept legal variable names, like `hello_01`
+            elsif scanner.scan(/^\w+/)
+              tokens << [:VAR_NAME, scanner.matched]
+            elsif scanner.scan(/\)/)
+              tokens << [:CLOSE_PARENS]
+              pop_state
+            else
+              no_match(scanner, state)
+            end
+
+          else
+            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
+
+      def no_match(scanner, state)
+        raise Aspen::LexError,
+                Aspen::Errors.messages(:unexpected_token, scanner, state)
+      end
+
+    end
+  end
+end

data/lib/aspen/custom_grammar/matcher.rb

@@ -0,0 +1,43 @@
+require 'mustache'
+
+module Aspen
+  module CustomGrammar
+    class Matcher
+
+      attr_accessor :expression, :template, :pattern, :typereg, :labelreg
+
+      def initialize(expression: , template: , pattern: )
+        @expression = expression
+        @template   = template
+        # SMELL: I don't like this design.
+        compiled_grammar = Aspen::CustomGrammar.compile(expression)
+        @pattern    = compiled_grammar[:pattern]
+        @typereg    = compiled_grammar[:type_registry]
+        @labelreg   = compiled_grammar[:label_registry]
+      end
+
+      def match?(str)
+        pattern.match?(str)
+      end
+
+      # Compare against narrative line to get captures
+      # Example results: { a: , amt: , b: }
+      def captures(str)
+        pattern.match(str).named_captures
+      end
+      alias_method :results, :captures
+
+      def captures!(str)
+        unless match?(str)
+          raise Aspen::MatchError,
+            Aspen::Errors.messages(:no_grammar_match, pattern, str)
+        end
+        captures(str)
+      end
+
+      alias_method :results!, :captures!
+
+
+    end
+  end
+end

data/lib/aspen/custom_grammar/parser.rb

@@ -0,0 +1,51 @@
+module Aspen
+  module CustomGrammar
+    class Parser < Aspen::AbstractParser
+
+      # expression = { segment }
+      # segment = BARE || capture_segment
+      # capture_segment = OPEN_PARENS, type, VAR_NAME, CLOSE_PARENS
+      # type = { node CONTENT } || numeric | float | integer | string
+
+      def parse
+        Aspen::CustomGrammar::AST::Nodes::Expression.new(parse_expression)
+      end
+
+      def parse_expression
+        segments = []
+
+        # Make sure this returns on empty
+        while segment = parse_segment
+          segments << segment
+          break if tokens[position].nil?
+        end
+
+        segments
+      end
+
+      def parse_segment
+        return parse_bare_segment || parse_capture_segment
+        raise Aspen::ParseError, "Didn't match expected tokens, got\n\t#{upcoming.inspect}"
+      end
+
+      def parse_bare_segment
+        if content = expect(:BARE)
+          Aspen::CustomGrammar::AST::Nodes::Bare.new(content.first.last)
+        end
+      end
+
+      def parse_capture_segment
+        if (_, type, var_name, _ = expect(:OPEN_PARENS, :TYPE, :VAR_NAME, :CLOSE_PARENS))
+          type_name, label = type.last
+
+          Aspen::CustomGrammar::AST::Nodes::CaptureSegment.new(
+            type:     type_name.to_sym,
+            var_name: var_name.last,
+            label:    label
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/custom_grammar.rb

@@ -0,0 +1,23 @@
+require 'aspen/custom_grammar/ast'
+require 'aspen/custom_grammar/lexer'
+require 'aspen/custom_grammar/parser'
+require 'aspen/custom_grammar/compiler'
+
+require 'aspen/custom_grammar/matcher'
+require 'aspen/custom_grammar/grammar'
+
+module Aspen
+  module CustomGrammar
+
+    def self.compile(expression)
+      tokens = Aspen::CustomGrammar::Lexer.tokenize(expression)
+      ast = Aspen::CustomGrammar::Parser.parse(tokens)
+      Aspen::CustomGrammar::Compiler.compile(ast)
+    end
+
+    def self.compile_pattern(expression)
+      self.compile(expression)[:pattern]
+    end
+
+  end
+end

data/lib/aspen/custom_statement.rb

@@ -0,0 +1,35 @@
+require 'dry/types'
+
+module Aspen
+  class CustomStatement < AbstractStatement
+
+    include Dry::Monads[:maybe]
+
+    attr_reader :nodes, :type
+
+    def type
+      :custom
+    end
+
+    # @todo The signature of the custom statement should be the
+    #   Cypher template for that statement.
+    def signature
+      "custom"
+    end
+
+    # @param nodes [Array<Aspen::Node>] a list of nodes
+    # @param cypher [String] the Cypher generated by the template
+    #   by the compiler
+    # @todo The inclusion of the Cypher parameter *suggests* that
+    #   there might be a better way to generate the Cypher from a
+    #   custom statement. Not sure.
+    def initialize(nodes: , cypher: )
+      @nodes  = nodes
+      @cypher = cypher
+    end
+
+    def to_cypher
+      @cypher
+    end
+  end
+end

data/lib/aspen/discourse.rb

@@ -0,0 +1,122 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'dry/monads'
+require 'yaml'
+
+require 'aspen/schemas/discourse_schema'
+
+module Aspen
+  class Discourse
+
+    include Dry::Monads[:maybe]
+
+    attr_reader :data, :grammar
+
+    def self.from_yaml(yaml)
+      from_hash YAML.load(yaml)
+    end
+
+    def self.from_hash(data = {})
+      raise ArgumentError, "Must be a hash, was a #{data.class}" unless data.is_a?(Hash)
+      result = Schemas::DiscourseSchema.call(data)
+      if result.success?
+        new(data)
+      else
+        # TODO: Improve this output for human readability
+        raise Aspen::Error, result.errors.messages.to_s
+      end
+    end
+
+    def self.assert(data)
+      return nil if data.nil?
+      case data.class.to_s
+      when "Aspen::Discourse" then data
+      when "Hash"   then from_hash(data)
+      when "String" then from_yaml(data)
+      else
+        raise ArgumentError, "Must be a Hash, string (containing YAML), or Aspen::Discourse, got:\n\t#{data} (#{data.class})"
+      end
+    end
+
+    def initialize(data = {})
+      @data = data.with_indifferent_access
+      @grammar = Aspen::CustomGrammar::Grammar.new
+      process_grammar
+    end
+
+    def default_label
+      maybe_label = Maybe(@data.dig(:default, :label))
+      maybe_label.value_or(Aspen::SystemDefault.label)
+    end
+
+    def default_attr_name(label)
+      maybe_attr = Maybe(@data.dig(:default, :attributes, label.to_sym))
+      maybe_attr.value_or(primary_default_attr_name)
+    end
+
+    def allowed_labels
+      @al ||= whitelist_for(:nodes)
+    end
+
+    def allowed_edges
+      @ae ||= whitelist_for(:edges)
+    end
+
+    def allows_label?(label)
+      allowed_labels.empty? || allowed_labels.include?(label)
+    end
+
+    def allows_edge?(edge)
+      allowed_edges.empty? || allowed_edges.include?(edge)
+    end
+
+    def mutual
+      maybe_list = Maybe(@data.dig(:mutual) || @data.dig(:reciprocal))
+      maybe_list.value_or(Array.new)
+    end
+
+    def mutual?(edge_name)
+      mutual.include? edge_name
+    end
+
+    alias_method :reciprocal,  :mutual
+    alias_method :reciprocal?, :mutual?
+
+    def add_grammar(grammar)
+      @grammar = grammar
+    end
+
+    private
+
+    def primary_default_attr_name
+      maybe_attr = Maybe(@data.dig(:default, :attribute))
+      maybe_attr.value_or(Aspen::SystemDefault.attr_name)
+    end
+
+    def whitelist_for(stuff)
+      maybe_whitelist = Maybe(@data.dig(:allow_only, stuff))
+      list = maybe_whitelist.value_or([])
+      return list if list.is_a? Array  # If it's already a YAML list, great.
+      list.split(",").map(&:strip)      # Otherwise, split the comma-separated string
+    end
+
+    # Converts multiple lines
+    def process_grammar
+      return false unless configured_grammar
+      configured_grammar.each do |block|
+        Array(block.fetch(:match)).each do |expression|
+          matcher = Aspen::CustomGrammar::Matcher.new(
+            expression: expression,
+            template:   block.fetch(:template),
+            pattern:    Aspen::CustomGrammar.compile_pattern(expression)
+          )
+          grammar.add(matcher)
+        end
+      end
+    end
+
+    def configured_grammar
+      @cg ||= Maybe(@data.dig(:grammar)).value_or(false)
+    end
+
+  end
+end

data/lib/aspen/edge.rb

@@ -0,0 +1,35 @@
+module Aspen
+  class Edge
+
+    # @todo Rename :word to :label
+    def initialize(name, mutual: false)
+      @name = name
+      @mutual = mutual
+    end
+
+    def label
+      @name
+    end
+
+    def to_cypher
+      "-[:#{label.parameterize.underscore.upcase}]-#{cap}"
+    end
+
+    def signature
+      to_cypher.gsub(/:/, '')
+    end
+
+    def mutual?
+      @mutual
+    end
+
+    alias_method :reciprocal?, :mutual?
+
+    private
+
+    def cap
+      @mutual ? "" : ">"
+    end
+  end
+
+end