aspen-cli 0.1.2

data/lib/aspen/actions/watch.rb

@@ -0,0 +1,55 @@
+require 'listen'
+
+module Aspen
+  module Actions
+    class Watch
+
+      def initialize(options: {})
+        @options = options
+        @logger  = options.fetch(:logger) { Logger.new(STDOUT, level: :warn) }
+        Listen.logger = @logger
+      end
+
+      def call
+        puts warning_message if using_database?
+
+        listener = Listen.to('src/', only: /\.aspen$/) do |mod, add, _rem|
+          Aspen::CLI::Commands::Build.new.call
+          Aspen::Actions::Push.new.call
+        rescue Aspen::Error => e
+          puts e.message
+        end
+
+        listener.start
+        sleep
+      rescue Interrupt => e
+        # FIXME: The logger calls don't ever seem to work.
+        @logger.info "Exiting..."
+        puts "\nExiting..."
+        listener.stop
+        raise SystemExit
+      end
+
+      private
+
+        def using_database?
+          @options[:database]
+        end
+
+        def warning_message
+          <<~MSG
+            ⚠️ WARNING: `aspen watch` is experimental, and saving a file/rebuilding the data
+            will cause ALL OF THE DATA in the database to be DELETED and rewritten.
+
+            By proceeding, you acknowledge that the Neo4j database at TODO: host:port will
+            be dropped the next time a file in this project is saved.
+
+            Use Ctrl+C to quit.
+
+            Watching....
+          MSG
+        end
+
+    end
+  end
+end

data/lib/aspen/actions.rb

@@ -0,0 +1,8 @@
+module Aspen
+  module Actions
+  end
+end
+
+require 'aspen/actions/compile'
+require 'aspen/actions/push'
+require 'aspen/actions/watch'

data/lib/aspen/adapters.rb

@@ -0,0 +1,38 @@
+module Aspen
+  module Adapters
+
+    class Adapter
+      attr_reader :id, :name, :ext, :renderer
+
+      def initialize(id: , name: , ext: )
+        @id   = id
+        @name = name
+        @ext  = ext
+        # @todo This will be buggy if we have a two-word class
+        @renderer = Kernel.const_get("Aspen::Renderers::#{@name.downcase.capitalize}Renderer")
+      end
+    end
+
+    class Registry
+
+      attr_reader :data
+
+      def initialize
+        @data ||= {
+          cypher: Adapter.new(id: :cypher, name: "Cypher", ext: '.cql' ),
+          json:   Adapter.new(id: :json,   name: "JSON",   ext: '.json'),
+          gexf:   Adapter.new(id: :gexf,   name: "GEXF",   ext: '.gexf'),
+        }
+        Aspen.available_formats = @data.keys
+      end
+
+      def self.get(key)
+        # @todo There's a better design for this.
+        @@store ||= new.data
+        @@store.fetch(key)
+      end
+
+    end
+
+  end
+end

data/lib/aspen/ast/nodes/attribute.rb

@@ -0,0 +1,16 @@
+module Aspen
+  module AST
+    module Nodes
+      class Attribute
+
+        attr_reader :content, :type
+
+        def initialize(content)
+          @content = Aspen::AST::Nodes::Content.new(content)
+          @type    = Aspen::AST::Nodes::Type.determine(content)
+        end
+
+      end
+    end
+  end
+end

data/lib/aspen/ast/nodes/comment.rb

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

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

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

data/lib/aspen/ast/nodes/custom_statement.rb

@@ -0,0 +1,19 @@
+module Aspen
+  module AST
+    module Nodes
+      class CustomStatement
+
+        attr_reader :content
+
+        # I wonder: Should the AST for CustomGrammar be grouped
+        # into lib/ast? Should the CustomStatement AST node contain
+        # the Bare Segments and Capture Segments, along with
+        # variables with types and labels?
+        def initialize(content)
+          @content = Aspen::AST::Nodes::Content.new(content)
+        end
+
+      end
+    end
+  end
+end

data/lib/aspen/ast/nodes/edge.rb

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

data/lib/aspen/ast/nodes/label.rb

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

data/lib/aspen/ast/nodes/narrative.rb

@@ -0,0 +1,15 @@
+module Aspen
+  module AST
+    module Nodes
+      class Narrative
+
+        attr_reader :statements
+
+        def initialize(statements)
+          @statements = statements
+        end
+
+      end
+    end
+  end
+end

data/lib/aspen/ast/nodes/node.rb

@@ -0,0 +1,20 @@
+module Aspen
+  module AST
+    module Nodes
+      class Node
+
+        attr_reader :attribute, :label
+
+        def initialize(attribute: , label: nil)
+          @attribute = Aspen::AST::Nodes::Attribute.new(attribute)
+          @label     = Aspen::AST::Nodes::Label.new(label)
+        end
+
+        def label=(content)
+          @label = Aspen::AST::Nodes::Label.new(content)
+        end
+
+      end
+    end
+  end
+end

data/lib/aspen/ast/nodes/statement.rb

@@ -0,0 +1,17 @@
+module Aspen
+  module AST
+    module Nodes
+      class Statement
+
+        attr_reader :origin, :edge, :target
+
+        def initialize(origin: nil, edge: nil, target: nil)
+          @origin = origin
+          @edge   = edge
+          @target = target
+        end
+
+      end
+    end
+  end
+end

data/lib/aspen/ast/nodes/type.rb

@@ -0,0 +1,46 @@
+module Aspen
+  module AST
+    module Nodes
+      class Type
+
+        STRING  = "STRING"
+        INTEGER = "INTEGER"
+        FLOAT   = "FLOAT"
+
+        MATCH_FLOAT   = /^([\d,]+\.\d+)$/
+        MATCH_INTEGER = /^([\d,]+)$/
+        MATCH_STRING  = /^(.+)$/
+
+        def self.determine(value)
+          new(
+            case value
+            when MATCH_FLOAT   then FLOAT
+            when MATCH_INTEGER then INTEGER
+            when MATCH_STRING  then STRING            
+            else
+              raise ArgumentError, "Could not determine a type for value:\n\t#{value.inspect}"
+            end
+          )
+        end
+
+        attr_reader :content, :converter
+
+        def initialize(type_const)
+          @content   = Aspen::AST::Nodes::Content.new(type_const)
+          @converter = get_converter(type_const)
+        end
+
+        def get_converter(type_const)
+          case type_const
+          when FLOAT   then :to_f
+          when INTEGER then :to_i
+          when STRING  then :to_s
+          else
+            raise ArgumentError, "Could not determine a converter method for type:\n\t#{value.inspect}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aspen/ast.rb

@@ -0,0 +1,18 @@
+module Aspen
+  module AST
+    module Nodes
+    end
+  end
+end
+
+require 'aspen/ast/nodes/attribute'
+require 'aspen/ast/nodes/type'
+
+require 'aspen/ast/nodes/comment'
+require 'aspen/ast/nodes/content'
+require 'aspen/ast/nodes/edge'
+require 'aspen/ast/nodes/label'
+require 'aspen/ast/nodes/narrative'
+require 'aspen/ast/nodes/node'
+require 'aspen/ast/nodes/statement'
+require 'aspen/ast/nodes/custom_statement'

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

@@ -0,0 +1,26 @@
+require 'csv'
+require 'aspen/cli/commands/build_steps'
+
+module Aspen
+  module CLI
+    module Commands
+
+      class Build < Dry::CLI::Command
+        desc "Build Aspen project"
+
+        option :batch, type: :boolean, desc: "Batching", default: true
+
+        include BuildSteps
+
+        def call(**options)
+          CheckAspenProject.new.call
+          DownloadAttachedResources.new.call
+          ConvertIntoAspen.new.call
+          main_aspen_file = CollectMainAspen.new.call
+          CompileMainAspen.new.call(main_aspen_file, options)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+require 'airtable'
+
+module Aspen
+  module CLI
+    module Commands
+      module BuildSteps
+
+        class BuildStep
+          def manifest
+            return @manifest if @manifest
+            @manifest = @files.exist?('manifest.yml') ? YAML.load_file('manifest.yml') : {}
+          end
+
+          def config
+            return @config if @config
+            @config = {}
+            Dir['config/*.yml'].each do |path|
+              key = File.basename(path, File.extname(path))
+              value = YAML.load_file(path)
+              @config[key.to_s] = value
+            end
+            @config
+          end
+
+          def call(*)
+            @files = Dry::CLI::Utils::Files
+          end
+        end
+
+
+        class CheckAspenProject < BuildStep
+          # Check if we're in an Aspen project, and stop if not.
+          def call(*)
+            super
+            unless @files.exist?('.aspen')
+              raise ArgumentError, "Must be within an Aspen project to run `build`"
+            end
+          end
+        end # / CheckAspenProject
+
+
+        class DownloadAttachedResources < BuildStep
+          def call(*)
+            super
+            return false unless manifest['attached']
+            check_for_save_file
+            if cache_expired?
+              download
+              update_save_file!
+            else
+              puts "----> Skipping download, cache is still good."
+            end
+          end
+
+          def check_for_save_file
+            unless @files.exist?('build/last-download')
+              File.open('build/last-download', 'w') { |f| f << 0 }
+            end
+          end
+
+          def cache_expired?
+            if manifest["cache_seconds"]
+              last = File.read('build/last-download').to_i       # Last download time
+              time_since_last_download = (Time.now - last).to_i  # Time since last download
+              threshhold = manifest['cache_seconds'].to_i        # Cache threshhold
+              time_since_last_download > threshhold
+            end
+          end
+
+          def update_save_file!
+            File.open('build/last-download', 'w') { |f| f << Time.now.to_i }
+          end
+
+          def download
+            puts '----> Downloading attached resources'
+            manifest['attached'].each do |resource|
+              puts "      > Downloading #{resource["name"]} (#{resource["source"].capitalize})"
+              case resource["source"]
+              when "airtable" then download_airtable_resource(resource)
+              end
+            end
+          end
+
+          def download_airtable_resource(resource)
+            client = Airtable::Client.new(config.dig('airtable', 'api_key'))
+            table = client.table(resource['app_id'], resource['table'])
+            out_path = "src/#{resource["name"].downcase.gsub(" ", "_")}.csv"
+            CSV.open(out_path, 'w') do |file|
+              columns = Array(resource['columns'])
+              file << columns
+              table.records.each do |record|
+                file << columns.map { |col| record[col] }
+              end
+            end
+          end
+
+        end # / DownloadAttachedResources
+
+        class ConvertIntoAspen < BuildStep
+          def call(*)
+            super
+            puts "----> Converting non-Aspen to Aspen (bin/convert)"
+            if @files.exist?('bin/convert')
+              unless system('bin/convert')
+                raise RuntimeError, "`bin/convert` didn't work, stopping build. See above Traceback."
+              end
+            end
+          end
+        end # / ConvertIntoAspen
+
+
+        class CollectMainAspen < BuildStep
+          def call(*)
+            super
+            # Grab all the grammars and Aspen source files, make into one main Aspen file.
+            puts "----> Collecting main.aspen from src/ and src/grammars"
+
+            # Clear the build/ folder
+            Dir["build/main-*"].each { |path| @files.delete(path)}
+
+            @grammars   = "" # Main grammars IO
+            @discourses = "" # Main discourses IO
+            @aspens     = "" # Main Aspen IO
+
+            collect_discourses
+            collect_grammars
+            collect_aspen
+
+            main_aspen = File.open("build/main-#{Time.now.to_i}.aspen", 'w') do |file|
+              file << @discourses
+              file << @grammars
+              file << Aspen::SEPARATOR + "\n"
+              file << @aspens
+            end
+            return main_aspen
+          end
+
+          def collect_discourses
+            Dir['src/discourses/*.aspen'].map do |path|
+              # Skip if there's an ignore: src: in the manifest, and if it matches the file path
+              next if manifest.dig("ignore", "discourses") && manifest.dig("ignore", "discourses").any? { |ignore_path| Regexp.new(ignore_path) =~ path }
+              @discourses << File.read(path)
+            end
+          end
+
+          def collect_grammars
+            Dir['src/grammars/*.aspen'].map do |path|
+              # Skip if there's an ignore: src: in the manifest, and if it matches the file path
+              next if manifest.dig("ignore", "grammars") && manifest.dig("ignore", "grammars").any? { |ignore_path| Regexp.new(ignore_path) =~ path }
+              @grammars << File.read(path)
+            end
+          end
+
+          def collect_aspen
+            Dir['src/*.aspen'].map do |path|
+              next if manifest.dig("ignore", "src") && manifest.dig("ignore", "src").any? do |ignore_path|
+                Regexp.new(ignore_path) =~ path
+              end
+              File.read(path)
+            end.compact.each do |file|
+              if file.include?(SEPARATOR)
+                env, _sep, code = file.partition(SEPARATOR)
+                @discourses << env
+                @aspens << code
+              else
+                @aspens << file
+              end
+            end
+          end
+        end # / CollectMainAspen
+
+
+        class CompileMainAspen < BuildStep
+
+          def call(main_aspen_file, options)
+            super
+            puts "----> Compiling main Aspen file (#{main_aspen_file.path})"
+            # Compile the main Aspen file, according to manifest.yml
+            unless manifest["output"]
+              puts "      Defaulting to Cypher output. To customize, set up a manifest.yml."
+            end
+
+            outputs = manifest["output"] ? Array(manifest["output"]) : ["Cypher"]
+
+            outputs.each do |format|
+              adapter = Aspen::Adapters::Registry.get(format.downcase.to_sym)
+              out_path = main_aspen_file.path.gsub(/\.aspen$/, '') + adapter.ext
+
+              File.open(out_path, 'w') do |file|
+                file << Aspen.compile_text(
+                  File.read(main_aspen_file),
+                  adapter: adapter.id,
+                  batch: options[:batch]
+                )
+              end
+              puts "----> Compiled main #{adapter.name} file"
+            end
+          end
+        end # / CompileMainAspen
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'aspen/actions/compile'
+
+module Aspen
+  module CLI
+    module Commands
+
+      class Compile < Dry::CLI::Command
+        desc "Compile an Aspen file to Cypher (in the same directory)"
+
+        argument :path, required: true, desc: "Aspen file to compile to Cypher"
+
+        option :database, type: :string, desc: "Database URL", aliases: ["d"]
+        # option :mode, default: "http", values: %w[http https bolt], desc: "The connection protocol"
+
+        example [
+          "path/to/file.aspen                                      # Compiles to path/to/file.cypher",
+          "path/to/file.aspen -d http://neo4j:pass@localhost:11002 # Compiles and runs in database"
+        ]
+
+        def call(path: , **options)
+          Aspen::Actions::Compile.new(path, options).call
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Aspen
+  module CLI
+    module Commands
+
+      module Generate
+        class Discourse < Dry::CLI::Command
+          desc "Generate a new discourse within a project"
+          def call()
+            # NO OP
+          end
+        end
+
+        class Narrative < Dry::CLI::Command
+          desc "Generate a new narrative within a project"
+          def call()
+            # NO OP
+          end
+        end
+      end
+
+    end
+  end
+end