aspen-cli 0.1.2

data/lib/aspen/cli/commands/new.rb

@@ -0,0 +1,115 @@
+require 'erb'
+require 'fileutils'
+
+module Aspen
+  module CLI
+    module Commands
+
+      class New < Dry::CLI::Command
+        desc "Generate a new Aspen project"
+
+        argument :project_name,
+          desc: "Name for new Aspen project",
+          required: true
+
+        option :database_url,
+          desc: "Database to push Aspen data to",
+          aliases: ["d"],
+          default: "http://neo4j:pass@localhost:7474/",
+          required: false
+
+        option :docker,
+          desc: "Generate a Docker Compose file for a Neo4j database",
+          type: :boolean,
+          default: true,
+          required: false
+
+        def call(project_name: , **options)
+          f = Dry::CLI::Utils::Files
+          root = Pathname.new(__FILE__).join("..")
+
+          if f.exist?("#{project_name}/.aspen")
+            raise RuntimeError, "There is already an Aspen project at #{project_name}, stopping."
+          end
+
+          URI.parse(options[:database_url])
+
+          puts "\nGenerated:"
+          puts "----------"
+
+          f.mkdir "#{project_name}/"
+          puts "    #{project_name}/                      -> Project folder"
+
+          f.touch "#{project_name}/.aspen"
+          puts "    #{project_name}/.aspen                -> File indicating Aspen project "
+
+          File.open("#{project_name}/manifest.yml", 'w') do |file|
+            template = get_template_file('manifest.yml.erb')
+            file << ERB.new(template).result_with_hash(project_name: project_name)
+          end
+          puts "    #{project_name}/manifest.yml          -> Metadata about included files"
+
+          f.touch "#{project_name}/config/db.yml"
+          File.open("#{project_name}/config/db.yml", 'w') do |file|
+            template = get_template_file('db.yml.erb')
+            file << ERB.new(template).result_with_hash(database_url: options[:database_url])
+          end
+          puts "    #{project_name}/config/db.yml         -> Database configuration"
+
+          if options[:docker]
+            f.cp get_template_path("docker-compose.yml"), "#{project_name}/docker-compose.yml"
+            puts "    #{project_name}/docker-compose.yml    -> Docker Compose file for Neo4j"
+          else
+            puts "    Skipping Docker Compose file"
+          end
+
+          f.mkdir "#{project_name}/src/"
+          puts "    #{project_name}/src/                  -> Source files"
+
+          f.mkdir "#{project_name}/bin/"
+          puts "    #{project_name}/bin/                  -> Binary files (scripts)"
+
+          f.cp get_template_path("convert"), "#{project_name}/bin/convert"
+          FileUtils.chmod("+x", "#{project_name}/bin/convert")
+          puts "    #{project_name}/bin/convert           -> Converts non-Aspen to Aspen"
+
+          f.mkdir "#{project_name}/src/discourses/"
+          f.touch "#{project_name}/src/discourses/.gitkeep"
+          puts "    #{project_name}/src/discourses/       -> Collection of Discourses"
+
+          f.mkdir "#{project_name}/src/grammars/"
+          f.touch "#{project_name}/src/grammars/.gitkeep"
+          puts "    #{project_name}/src/grammars/         -> Collection of Grammars"
+
+          f.mkdir "#{project_name}/build/"
+          f.touch "#{project_name}/build/.gitkeep"
+          puts "    #{project_name}/build/                -> Compilation is output here"
+
+          f.cp get_template_path(".gitignore"), "#{project_name}/.gitignore"
+          f.touch "#{project_name}/.gitignore"
+          puts "    #{project_name}/.gitignore            -> Ignoring config files, build files"
+
+          if options[:docker]
+            puts "\nTo start the Neo4j database, run `docker-compose up` from the #{project_name} folder"
+          end
+          puts "\n✅ Generated new project '#{project_name}'\n\n"
+        end
+
+        def get_template_file(name)
+          File.read(
+            get_template_path(name)
+          )
+        end
+
+        def get_template_path(name)
+          File.expand_path(
+            File.join(
+              File.dirname(__FILE__), "..", "templates", name
+            )
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/cli/commands/push.rb

@@ -0,0 +1,15 @@
+module Aspen
+  module CLI
+    module Commands
+
+      class Push < Dry::CLI::Command
+        desc "Push latest Cypher"
+
+        def call(*)
+          Aspen::Actions::Push.new.call
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/cli/commands/version.rb

@@ -0,0 +1,15 @@
+module Aspen
+  module CLI
+    module Commands
+
+      class Version < Dry::CLI::Command
+        desc "Print version"
+
+        def call(*)
+          puts Aspen::VERSION
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/cli/commands/watch.rb

@@ -0,0 +1,30 @@
+require 'aspen/actions/watch'
+
+module Aspen
+  module CLI
+    module Commands
+
+      module Watch
+        class Run < Dry::CLI::Command
+          desc "Watch the project for changes; rebuild and push"
+
+          option :database,
+            type:    :boolean,
+            default: true,
+            desc:    "Push to sandbox database in config/db.yml",
+            aliases: ["d"]
+
+          example [
+            "   # Recompiles and pushes to database",
+            "-D # Only recompiles files",
+          ]
+
+          def call(**options)
+            Aspen::Actions::Watch.new(options: options).call
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/cli/commands.rb

@@ -0,0 +1,28 @@
+require 'aspen/cli/commands/version'
+require 'aspen/cli/commands/compile'
+require 'aspen/cli/commands/new'
+require 'aspen/cli/commands/push'
+# require 'aspen/cli/commands/watch'
+require 'aspen/cli/commands/build'
+
+module Aspen
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register "version", Version, aliases: ["v", "-v", "--version"]
+      register "compile", Compile, aliases: ["c"]
+      register "build",   Build,   aliases: ["b"]
+      register "push",    Push,    aliases: ["p"]
+
+      # register "watch", Watch::Run, aliases: ["w"]
+
+      register "new", New
+
+      # register "generate", aliases: ["g"] do |prefix|
+      #   prefix.register "discourse", Generate::Discourse
+      #   prefix.register "narrative", Generate::Narrative
+      # end
+    end
+  end
+end

data/lib/aspen/cli/templates/.gitignore

@@ -0,0 +1,6 @@
+# Build folder
+build/
+
+# Authorization secrets
+.env
+config/*.yml

data/lib/aspen/cli/templates/airtable.yml

@@ -0,0 +1 @@
+# api_key: your Airtable API key

data/lib/aspen/cli/templates/convert

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+# This file is used to convert any non-Aspen resources,
+# such as CSV files or other data, into Aspen before
+# building the project.
+
+require 'aspen'
+require 'aspen/helpers'
+require 'aspen/conversion'
+
+include Aspen::Helpers
+include Aspen::Conversion
+
+# Aspen.convert.csv('src/a_spreadsheet.csv').to_aspen do |csv, aspen|
+#   TODO: Do conversion work here
+# end

data/lib/aspen/cli/templates/db.yml.erb

@@ -0,0 +1,22 @@
+# WARNING!
+#    WARNING!
+#       WARNING!
+
+# This should NEVER point to a production database or any
+# database that you need the data to persist in.
+
+# This should only ever point to a Sandbox database that
+# you are comfortable completely deleting each time
+# you rebuild these Aspen files.
+
+<%
+require 'uri'
+
+begin
+  uri = URI.parse(database_url)
+rescue URI::InvalidURIError
+  raise "Invalid database URL"
+end
+%>
+
+url: <%= database_url %>

data/lib/aspen/cli/templates/docker-compose.yml

@@ -0,0 +1,23 @@
+services:
+
+  neo4j:
+    image: neo4j:3.5.11
+    volumes:
+      - ./db/data:/data
+      - ./db/plugins:/plugins
+      - ./db/logs:/logs
+    ports:
+      - 7474:7474
+      - 7687:7687
+    environment:
+      - NEO4J_AUTH=neo4j/pass
+      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
+      - NEO4JLABS_PLUGINS=["apoc"]
+      - NEO4J_apoc_export_file_enabled=true
+      - NEO4J_apoc_import_file_enabled=true
+      - NEO4J_apoc_import_file_use__neo4j__config=true
+      - NEO4J_dbms_security_procedures_whitelist=apoc.*
+      - NEO4J_dbms_security_procedures_unrestricted=apoc.*
+
+volumes:
+  neo4j:

data/lib/aspen/cli/templates/manifest.yml.erb

@@ -0,0 +1,31 @@
+project_name: <%= project_name %>
+
+# These list the output formats that `aspen build` will produce.
+# Remove lines to remove that file from the build.
+output:
+  - Cypher
+  - JSON
+  - GEXF
+
+# Uncomment to ignore files in src/ or src/grammars
+# ignore:
+#   src:
+#     - specific_aspen_or_csv_file
+#   grammars:
+#     - default
+
+# Attach a file from Airtable with the following format
+# attached:
+#   -
+#     name:   { Name of resource, displayed in prompt. Not connected to Airtable. }
+#     source: airtable
+#     app_id: { your app ID (API key) }
+#     table:  { Name of table in Airtable }
+#     columns:
+#       - Columns
+#       - To
+#       - Download
+
+# How long to wait before re-downloading files (in seconds)
+# If no cache_seconds is specified, it will re-download every time.
+# cache_seconds: 300

data/lib/aspen/cli.rb

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'dry/cli'
+require 'dry/cli/utils/files'
+
+require 'listen'
+require 'aspen'
+
+require 'aspen/cli/commands'
+require 'aspen/actions'

data/lib/aspen/compiler.rb

@@ -0,0 +1,209 @@
+require 'dry/monads'
+include Dry::Monads[:maybe]
+
+module Aspen
+  class Compiler
+
+    attr_reader :root, :environment
+
+    # @param environment [Hash]
+    # @todo Make {environment} an Aspen::Environment
+    def self.render(root, environment = {})
+      new(root, environment).render
+    end
+
+    # @param environment [Hash]
+    # @todo Make {environment} an Aspen::Environment
+    def initialize(root, environment = {})
+      @root = root
+      @environment = environment
+      @adapter = environment.fetch(:adapter, :cypher).to_sym
+      # @todo FIXME: This is too much responsibility for the compiler.
+      #   This should be delegated to an object and the later calls
+      #   just messages to that object.
+      @slug_counters = Hash.new { 1 }
+
+      # @todo Move this into an Environment object—it should be set there.
+      #   and here, just run environment.validate
+      unless Aspen.available_formats.include?(@adapter)
+        raise Aspen::ArgumentError, <<~MSG
+          The adapter, also known as the output format, must be one of:
+          #{Aspen.available_formats.join(', ')}.
+
+          What Aspen received was #{@adapter}.
+        MSG
+      end
+    end
+
+    def render
+      visit(root)
+    end
+
+    def discourse
+      @discourse ||= Discourse.from_hash(environment)
+    end
+
+    def visit(node)
+      short_name = node.class.to_s.split('::').last.downcase
+      method_name = "visit_#{short_name}"
+      send(method_name, node)
+    end
+
+    def visit_narrative(node)
+      # Instead of letting comments be `nil` and using `#compact`
+      # to silently remove them, possibly hiding errors, we "compile"
+      # comments as `:comment` and filter them explicitly
+      statements = node.statements.map do |statement|
+        # This will visit both regular and custom statements.
+        visit(statement)
+      end.reject { |elem| elem == :comment }
+
+      renderer_klass = Kernel.const_get("Aspen::Renderers::#{@adapter.to_s.downcase.capitalize}Renderer")
+      renderer_klass.new(statements, environment).render
+    end
+
+    def visit_statement(node)
+      Statement.new(
+        origin: visit(node.origin),
+        edge: visit(node.edge),
+        target: visit(node.target)
+      )
+    end
+
+    # @todo Get the labels back into here. Labelreg? typereg[:labels]?
+    #   This is doing too much.
+    #   Can't we have typed attributes come from the Grammar?
+    def visit_customstatement(node)
+      statement = visit(node.content)
+      matcher   = discourse.grammar.matcher_for(statement)
+      results   = matcher.captures(statement)
+      template  = matcher.template
+      typereg   = matcher.typereg
+      labelreg  = matcher.labelreg
+
+      nodes = []
+
+      typed_results = results.inject({}) do |hash, elem|
+        key, value = elem
+        typed_value = case typereg[key]
+        when :integer then value.to_i
+        when :float   then value.to_f
+        when :numeric then
+          value.match?(/\./) ? value.to_f : value.to_i
+        when :string  then "\"#{value}\""
+        when :node    then
+          # FIXME: This only handles short form.
+          #   I think we were allowing grouped and Cypher form to fill
+          #   in custom statement templates.
+          # TODO: Add some object to nodes array.
+          node = visit(
+            Aspen::AST::Nodes::Node.new(
+              attribute: value,
+              label: labelreg[key]
+            )
+          )
+          nodes << node
+          node
+        end
+        hash[key] = typed_value
+        hash
+      end
+
+      formatted_results = typed_results.inject({}) do |hash, elem|
+        key, value = elem
+        f_value = value.is_a?(Aspen::Node) ? value.nickname_node : value
+        hash[key] = f_value
+
+        # TODO: Trying to insert a p_id as well as p to be used in JSON identifiers.
+        # if value.is_a?(Aspen::Node)
+        #   hash["#{key}_id"] = value.nickname
+        # end
+        # puts "TYPED VALS: #{hash.inspect}"
+        hash
+      end
+
+      slugs = template.scan(/{{{?(?<full>uniq_(?<name>\w+))}}}?/).uniq
+      usable_results = if slugs.any?
+        counts = slugs.map do |full, short|
+          [full, "#{short}_#{@slug_counters[full]}"]
+        end.to_h
+
+        context = results.merge(counts)
+        custom_statement = CustomStatement.new(
+          nodes: nodes,
+          cypher: Mustache.render(template.strip, formatted_results.merge(counts))
+        )
+        slugs.each do |full, _|
+          @slug_counters[full] = @slug_counters[full] + 1
+        end
+        custom_statement
+      else
+        CustomStatement.new(
+          nodes: nodes,
+          cypher: Mustache.render(template.strip, formatted_results)
+        )
+      end
+    end
+
+    def visit_node(node)
+      # Get the label, falling back to the default label.
+      label = visit(node.label)
+
+      # Get the attribute name, falling back to the default attribute name.
+      attribute_name  = Maybe(nil).value_or(discourse.default_attr_name(label))
+      typed_attribute_value = visit(node.attribute)
+      nickname = typed_attribute_value.to_s.downcase
+
+      Aspen::Node.new(
+        label: label,
+        attributes: { attribute_name => typed_attribute_value }
+      )
+    end
+
+    def visit_edge(node)
+      content = visit(node.content)
+      unless discourse.allows_edge?(content)
+        raise Aspen::Error, """
+          Your narrative includes an edge called '#{content}',
+          but only #{discourse.allowed_edges} are allowed.
+        """
+      end
+      Aspen::Edge.new(
+        content,
+        mutual: discourse.mutual?(visit(node.content))
+      )
+    end
+
+    def visit_label(node)
+      content = visit(node.content)
+      label = Maybe(content).value_or(discourse.default_label)
+      unless discourse.allows_label?(label)
+        raise Aspen::CompileError, """
+          Your narrative includes a node with label '#{label}',
+          but only #{discourse.allowed_labels} are allowed.
+        """
+      end
+      label
+    end
+
+    def visit_attribute(node)
+      content = visit(node.content)
+      type    = visit(node.type)
+      content.send(type.converter)
+    end
+
+    def visit_type(node)
+      node
+    end
+
+    def visit_content(node)
+      node.content
+    end
+
+    # @returns [Symbol] :comment
+    # This acts as a signal so other methods know to reject comments.
+    def visit_comment(node)
+      :comment
+    end
+  end
+end

data/lib/aspen/contracts/default_attribute_contract.rb

@@ -0,0 +1,29 @@
+require 'dry/validation'
+
+module Aspen
+  module Contracts
+    class DefaultAttributeContract < Dry::Validation::Contract
+
+      LABEL = /^[A-Z]{1}\w+$/
+      ATTR_NAME = /^[a-z]{1}[a-z_]*[a-z]{1}$/
+
+      schema do
+        required(:label).value(:string)
+        required(:attr_name).value(:string)
+      end
+
+      rule(:label) do
+        unless LABEL.match?(value)
+          key.failure("must be a valid Neo4j label (one TitleCase word), was #{value}")
+        end
+      end
+
+      rule(:attr_name) do
+        unless ATTR_NAME.match?(value)
+          key.failure("must be a single token in snake_case (lowercase and underscores only), was: #{value}")
+        end
+      end
+
+    end
+  end
+end

data/lib/aspen/contracts.rb

@@ -0,0 +1 @@
+require 'aspen/contracts/default_attribute_contract'

data/lib/aspen/conversion.rb

@@ -0,0 +1,43 @@
+require 'csv'
+
+module Aspen
+  # Helps convert non-Aspen into Aspen
+  # before compiling Aspen into other code.
+  module Conversion
+    class Builder
+      def initialize(args = {})
+        @from_format = args[:format]
+        @from_file   = args[:file]
+        @csv_options = { headers: true }
+      end
+
+      def csv(path)
+        @from_format = :csv
+        @from_path   = path
+        self
+      end
+
+      def tsv(path)
+        @from_format = :csv
+        @from_path   = path
+        @csv_options[:col_sep] = "\t"
+        self
+      end
+
+      def to_aspen(&block)
+        file  = CSV.open(@from_path, @csv_options)
+        aspen = File.open(@from_path.rpartition(".").first + ".aspen", 'w')
+        yield file, aspen
+      ensure
+        aspen.close
+      end
+    end
+  end
+
+  # @example
+  #   Aspen.convert.csv('path/to/csv').to_aspen
+  def self.convert
+    Aspen::Conversion::Builder.new({})
+  end
+
+end

data/lib/aspen/custom_grammar/ast/nodes/bare.rb

@@ -0,0 +1,17 @@
+module Aspen
+  module CustomGrammar
+    module AST
+      module Nodes
+        class Bare
+
+          attr_reader :content
+
+          def initialize(content)
+            @content = Content.new(content)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aspen/custom_grammar/ast/nodes/capture_segment.rb

@@ -0,0 +1,19 @@
+module Aspen
+  module CustomGrammar
+    module AST
+      module Nodes
+        class CaptureSegment
+
+          attr_reader :type, :var_name, :label
+
+          def initialize(type: , var_name: , label: )
+            @type     = type
+            @var_name = var_name
+            @label    = label
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aspen/custom_grammar/ast/nodes/content.rb

@@ -0,0 +1,17 @@
+module Aspen
+  module CustomGrammar
+    module AST
+      module Nodes
+        class Content
+
+          attr_reader :content
+
+          def initialize(content)
+            @content = content
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aspen/custom_grammar/ast/nodes/expression.rb

@@ -0,0 +1,17 @@
+module Aspen
+  module CustomGrammar
+    module AST
+      module Nodes
+        class Expression
+
+          attr_reader :segments
+
+          def initialize(segments=[])
+            @segments = segments
+          end
+
+        end
+      end
+    end
+  end
+end