brandish 0.1.1

data/lib/brandish/application/bench_command.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Application
+    # The bench command.  This builds the project in the set directory,
+    # and benchmarks.  This is for debugging.
+    class BenchCommand
+      include Commander::Methods
+
+      # Defines the command on the given application.  This sets the important
+      # data information for the command, for use for the help output.
+      #
+      # @param application [Application]
+      # @param command [Commander::Command]
+      # @return [void]
+      def self.define(application, command)
+        command.syntax = "brandish build"
+        command.option "-o", "--only NAMES", [::String]
+        command.option "-p", "--path PATH", ::String
+        command.option "-n", "--name NAME", ::String
+
+        command.action { |_, o| call(application, o.__hash__) }
+      end
+
+      # The default options for the build command.
+      #
+      # @return [{::Symbol => ::Object}]
+      DEFAULTS = { only: :all, path: "profile", name: "default" }.freeze
+
+      # Performs the build command.  This initializes the command, and
+      # calls {#call}.
+      #
+      # @param application [Application] The application.
+      # @param options [{::Symbol => ::Object}] The options for the command.
+      #
+      # @return [void]
+      def self.call(application, options)
+        new(application, options).call
+      end
+
+      # Initialize the build command.
+      #
+      # @params (see {.call})
+      def initialize(application, options)
+        @application = application
+        @options = DEFAULTS.merge(options)
+      end
+
+      # Performs the build.  First, it loads the configuration file for the
+      # build.  Then, it performs the build, calling {Configure#build} with
+      # the `:only` filter provided by the options.  This uses a Commander
+      # native called `progress` to make it look nice on the output.
+      #
+      # @return [void]
+      def call
+        require "ruby-prof"
+        require "benchmark"
+
+        @configure = @application.load_configuration_file
+        @path = ::Pathname.new(@options[:path]).expand_path(Dir.pwd)
+        @path.mkpath
+        say "=> Beginning build..."
+
+        result = nil
+        time = Benchmark.measure { result = RubyProf.profile { perform_build } }
+        say "-> Build ended, time: #{time}"
+        say "=> Outputting profile..."
+
+        result.eliminate_methods!(method_eleminations)
+        output_profile(result)
+      end
+
+    private
+
+      def output_profile(result)
+        printer = RubyProf::MultiPrinter.new(result)
+        printer.print(path: @path, profile: @options[:name])
+        say "-> Profile output to `#{@options[:path]}'!"
+      end
+
+      def perform_build
+        @configure.build(@options[:only]).each(&:call)
+      rescue => e
+        say_error "!> Error while building!"
+        say_error "-> Received exception: #{e.class}: #{e.message}"
+        e.backtrace.each { |l| say_warning "\t-> in #{l}" } if @options[:trace]
+        exit!
+      end
+
+      def method_eleminations
+        [/\A(Set|Class|Array|Enumerable)#/]
+      end
+    end
+  end
+end

data/lib/brandish/application/build_command.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Application
+    # The build command.  This just builds the project in the set directory.
+    class BuildCommand
+      include Commander::Methods
+
+      # The description for the build command.
+      #
+      # @return [::String]
+      COMMAND_DESCRIPTION =
+        "Builds an existing Brandish project.  If no directory is specified " \
+        " using --directory or -d, it defaults to the current directory."
+
+      # Defines the command on the given application.  This sets the important
+      # data information for the command, for use for the help output.
+      #
+      # @param application [Application]
+      # @param command [Commander::Command]
+      # @return [void]
+      def self.define(application, command)
+        command.syntax = "brandish build"
+        command.description = COMMAND_DESCRIPTION
+        command.option "-o", "--only NAMES", [::String],
+          "Which forms to build.  If this is omitted, it defaults to all."
+
+        command.action { |_, o| call(application, o.__hash__) }
+      end
+
+      # The default options for the build command.
+      #
+      # @return [{::Symbol => ::Object}]
+      DEFAULTS = { only: :all }.freeze
+
+      # Performs the build command.  This initializes the command, and
+      # calls {#call}.
+      #
+      # @param application [Application] The application.
+      # @param options [{::Symbol => ::Object}] The options for the command.
+      #
+      # @return [void]
+      def self.call(application, options)
+        new(application, options).call
+      end
+
+      # Initialize the build command.
+      #
+      # @params (see {.call})
+      def initialize(application, options)
+        @application = application
+        @options = DEFAULTS.merge(options)
+      end
+
+      # Performs the build.  First, it loads the configuration file for the
+      # build.  Then, it performs the build, calling {Configure#build} with
+      # the `:only` filter provided by the options.  This uses a Commander
+      # native called `progress` to make it look nice on the output.
+      #
+      # @return [void]
+      def call
+        configure = @application.load_configuration_file
+        @application.progress(configure.build(@options[:only]).to_a, &:call)
+      rescue => e
+        say_error "\n!> Error while building!"
+        say_error "!> #{e.location}" if e.respond_to?(:location)
+        say_error "!> Received exception: #{e.class}: #{e.message}"
+        e.backtrace.each { |l| say_warning "\t~> in #{l}" } if @options[:trace]
+      end
+    end
+  end
+end

data/lib/brandish/application/initialize_command.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "thor"
+require "rubygems"
+
+module Brandish
+  class Application
+    # The initialize command for the application.  This creates a new project
+    # at a given directory.  The Brandish project is placed at
+    # `directory`/`name`.
+    class InitializeCommand
+      include Thor::Base
+      include Thor::Actions
+
+      # The description for the initialize command.
+      #
+      # @return [::String]
+      COMMAND_DESCRIPTION =
+        "Creates a new Brandish project.  The name given should not contain " \
+        "any path seperators - if a brandish project needs to be placed in " \
+        "a seperate directory, use the --directory (or -d) option."
+
+      # The source root for the templates used by Thor for initialization.
+      #
+      # @return [::String]
+      def self.source_root
+        File.expand_path("../../../../templates/initialize", __FILE__)
+      end
+
+      # Defines the command on the given application.  This sets the important
+      # data information for the command, for use for the help output.
+      #
+      # @param application [Application]
+      # @param command [Commander::Command]
+      # @return [void]
+      def self.define(application, command)
+        command.syntax = "brandish initialize NAME"
+        command.description = COMMAND_DESCRIPTION
+
+        command.action { |a, o| call(application, a, o.__hash__) }
+      end
+
+      # Performs the initialize command.  Since this class uses Thor, this
+      # performs some setup to interface with the Thor class.
+      #
+      # @param application [Application]
+      # @param arguments [<::String>] The arguments passed to the initialize
+      #   command.  This should contain one value - the name.
+      # @param _options [Hash] The options for the command.  Since this command
+      #   takes no specific options, this is ignored.
+      # @return [void]
+      def self.call(application, arguments, _options)
+        name = arguments[0]
+        directory = application.directory / name
+        new([], { name: name }, destination_root: directory).call
+      end
+
+      # Performs the initialize command, setting up the project.
+      #
+      # @return [void]
+      def call
+        template "brandish.config.rb"
+        %w(source source/assets source/assets/styles source/assets/scripts
+          templates output).each { |d| empty_directory(d) }
+        template "Gemfile"
+        inside(".") { run "bundle install" }
+      end
+
+    protected
+
+      # The approximate recommendation for the current running version of
+      # Brandish.  This is used to set up a requirement for Brandish in both
+      # the Gemfile and the `brandish.config.rb` file.
+      #
+      # @return [::String]
+      def approx
+        @approx ||=
+          Gem::Version.new(Brandish::VERSION).approximate_recommendation
+      end
+    end
+  end
+end

data/lib/brandish/application/serve_command.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Application
+    # The serve command.  This builds, and then serves, an existing Brandish
+    # project.  This watches the source.  If it detects a change, it rebuilds.
+    class ServeCommand
+      include Commander::Methods
+
+      # The description for the serve command.
+      #
+      # @return [::String]
+      COMMAND_DESCRIPTION = "Builds, and serves, an existing Brandish project."
+
+      # Defines the command on the given application.  This sets the important
+      # data information for the command, for use for the help output.
+      #
+      # @param application [Application]
+      # @param command [Commander::Command]
+      # @return [void]
+      def self.define(application, command)
+        command.syntax = "branish serve"
+        command.description = COMMAND_DESCRIPTION
+        command.option "-p", "--port PORT", ::Integer, "The port to listen on"
+        command.option "-o", "--only NAMES", [::String], "The forms to build"
+        command.option "--verbose", "Whether or not to be verbose in the output"
+
+        command.action { |_, o| call(application, o.__hash__) }
+      end
+
+      # Performs the serve command.  This initializes the command, and
+      # calls {#call}.
+      #
+      # @param application [Application] The application.
+      # @param options [{::Symbol => ::Object}] The options for the command.
+      #
+      # @return [void]
+      def self.call(application, options)
+        puts "Running with options #{options.inspect}..."
+        new(application, options).call
+      end
+
+      # The default options for the serve command.
+      #
+      # @return [{::Symbol => ::Object}]
+      DEFAULTS = { only: :all, show_build: false }.freeze
+
+      # Initialize the serve command.
+      #
+      # @params (see {.call})
+      def initialize(application, options)
+        @application = application
+        @options = DEFAULTS.merge(options)
+        @port = @options.fetch(:port, (ENV["PORT"] || "3000").to_i)
+      end
+
+      # Performs the serve command.  It first loads the configuration file,
+      # then calls {#start_webserver}, followed by {#start_buildserver}.  Once
+      # both servers are setup, it calls {#wait_on_servers}.
+      #
+      # @return [void]
+      def call
+        @configuration = @application.load_configuration_file
+        say "=> Beginning serve..."
+        start_webserver
+        start_buildserver
+        color "\r=> Ready and waiting! ", :erase_line, :green
+        wait_on_servers
+      rescue StandardError, ScriptError => e
+        # Whenever we receive a general error, which only occurs while setup,
+        # we complain, and pass up the exception.
+        say_error "\n!> Received exception: #{e.class}: #{e.message}"
+        e.backtrace.each { |l| say_warning "\t-> in #{l}" } if @options[:trace]
+        fail
+      rescue SignalException, NoMemoryError, SystemExit, SystemStackError => e
+        # Whenever we receive a signal, or an unrecoverable error, we kill
+        # the servers and complain.  These exceptions occur on the main thread,
+        # and so we handle them here.
+        say_warning "\n!> Received exception: #{e.class}: #{e.message}"
+        say_ok "\n-> Received termination, shutting down..."
+        kill_webserver
+        kill_buildserver
+      end
+
+    private
+
+      def start_webserver
+        say "-> Setting up web server on port #{@port}..."
+        log_file = @options[:verbose] ? $stdout : StringIO.new
+        log = WEBrick::Log.new(log_file)
+        access_log = [[log_file, WEBrick::AccessLog::COMBINED_LOG_FORMAT]]
+        data = { Port: @port, DocumentRoot: @configuration.output.to_s,
+                 Logger: log, AccessLog: access_log }
+
+        @webserver = Thread.start { WEBrick::HTTPServer.new(data).start }
+      end
+
+      def print(a, *)
+        fail if a.is_a?(::IO)
+        super
+      end
+
+      def start_buildserver
+        perform_build
+        say "\n"
+        say "-> Setting up listen server..."
+        source_build_server = Listen.to(*listen_paths) { perform_build }
+        config_build_server = Listen.to(@application.directory.to_s) do
+          say "-> Configuration file changed, updating..."
+          @configuration = @application.load_configuration_file!
+          perform_build
+        end
+        config_build_server.only(/#{Regexp.escape(@application.config_file.to_s)}\z/)
+
+        @buildservers = [source_build_server, config_build_server].each(&:start)
+      end
+
+      def perform_build
+        builds = @configuration.build!(@options[:only])
+        color "\r~> Building... ", :erase_line, :clear
+        builds.each(&:call)
+        color "\r=> Build completed at #{Time.now.strftime('%T.%L')}! ", :erase_line, :green
+
+      rescue => e
+        say_error "\n!> Error while building!"
+        say_error "!> #{e.location}" if e.respond_to?(:location)
+        say_error "-> Received exception: #{e.class}: #{e.message}"
+        e.backtrace.each { |l| say_warning "\t-> in #{l}" } if @options[:trace]
+      end
+
+      def kill_webserver
+        @webserver&.kill
+      end
+
+      def kill_buildserver
+        @buildservers&.each { |b| b&.stop }
+      end
+
+      def wait_on_servers
+        @webserver.join
+      end
+
+      def listen_paths
+        (@configuration.sources.to_a + @configuration.templates.to_a)
+          .select(&:directory?).map(&:to_s)
+      end
+    end
+  end
+end

data/lib/brandish/configure.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "rubygems" # for Gem::Requirement
+require "securerandom"
+require "forwardable"
+
+require "brandish/configure/dsl"
+require "brandish/configure/form"
+
+module Brandish
+  # This provides a central location for all configuration options.  For the
+  # DSL, see {DSL}.
+  class Configure
+    extend Forwardable
+
+    # The options.  These can be anything; predefined options are `:root`,
+    # `:source`, `:output`, and `:templates`; for more information on those,
+    # see {#root}, {#sources}, {#output}, and {#templates} for more information.
+    # These options should not be accessed directly, but rather through their
+    # accessors.  Other options must be accessed through this.
+    #
+    # @return [{::Symbol => ::Object}]
+    attr_reader :options
+
+    # The forms that are defined on this configuration instance.
+    #
+    # @return [Set<Configure::Form>]
+    attr_reader :forms
+
+    # @!method [](key)
+    #   Sets a key on the options.  This gets an option that is used for all
+    #   processors on the options.
+    #
+    #   @param key [::Symbol, ::String] The key.
+    #   @return [::Object]
+    # @!method []=(key, value)
+    #   Sets a key on the options.  This sets an option that is used for all
+    #   processors on the options.
+    #
+    #   @param key [::Symbol, ::String] The key.
+    #   @param value [::Object] The value.
+    #   @return [::Object]
+    # @!method fetch(key, default = CANARY, &block)
+    #   Fetches a value at the given key, or provides a default if the key
+    #   doesn't exist.  If both a block and a default argument are given,
+    #   the block form takes precedence.
+    #
+    #   @overload fetch(key)
+    #     Attempts to retrieve a value at the given key.  If there is no
+    #     key-value pair at the given key, it raises an error.
+    #
+    #     @raise [KeyError] if the key isn't on the options.
+    #     @param key [::Symbol, ::String] The key.
+    #     @return [::Object] The value.
+    #
+    #  @overload fetch(key, default)
+    #    Attempts to retrieve a value at the given key.  If there is no
+    #    key-value pair at the given key, it returns the value given by
+    #    `default`.
+    #
+    #    @param key [::Symbol, ::String] The key.
+    #    @param default [::Object] The default value.
+    #    @return [::Object] The value, or the default value if there isn't
+    #      one.
+    #
+    #   @overload fetch(key, &block)
+    #     attempts to retrieve a value at the given key.  If there is no
+    #     key-value pair at the given key, it yields.
+    #
+    #     @yield if there is no corresponding key-value pair.
+    #     @param key [::Symbol, ::String] The key.
+    #     @return [::Object] The value, or the result of the block if there
+    #       isn't one.
+    delegate [:[], :fetch] => :options
+
+    # Initializes the configure instance.
+    #
+    # @param root [::String, ::Pathname] The root for the project.  This is
+    #   used to determine the correct paths for the output directory, the
+    #   sources directory, and the templates directory.
+    def initialize(root = Dir.pwd)
+      root = ::Pathname.new(root)
+      @options = { root: root, sources: PathSet.new, templates: PathSet.new }
+      @forms = ::Set.new
+      default_paths
+    end
+
+    # Retrieves the root path.  This is where all of the other directories
+    # should be located, and where the configuration file should be
+    # located.
+    #
+    # @return [::Pathname]
+    def root
+      fetch(:root)
+    end
+
+    # Retrieves the output path.  This is where the outputs for all of the forms
+    # should be located.
+    #
+    # @return [::Pathname]
+    def output
+      fetch(:output) { root / "output" }
+    end
+
+    # Retrieves the source path.  This is where the sources for all of the
+    # documents in the Brandish project are located.
+    #
+    # @return [PathSet]
+    def sources
+      fetch(:sources)
+    end
+
+    # Retrieves the templates path.  This is where all of the templates for
+    # all of the forms should be located.
+    #
+    # @return [PathSet]
+    def templates
+      fetch(:templates)
+    end
+
+    # Given a set of forms to build, it yields blocks that can be called to
+    # build a form.
+    #
+    # @param which [::Symbol, <::Symbol>] If this is `:all`, all of the forms
+    #   available are built; otherwise, it only builds the forms whose names
+    #   are listed.
+    # @yield [build] Yields for each form that can be built.
+    # @yieldparam build [::Proc<void>] A block that can be called to build
+    #   a form.
+    # @return [void]
+    def build(which = :all)
+      return to_enum(:build, which) unless block_given?
+      select_forms(which).each { |f| yield proc { f.build(self) } }
+    end
+
+    # Given a set of forms to build, it yields blocks that can be called to
+    # build a form.
+    #
+    # This first clears the cache for file nodes.
+    #
+    # @param which [::Symbol, <::Symbol>] If this is `:all`, all of the forms
+    #   available are built; otherwise, it only builds the forms whose names
+    #   are listed.
+    # @yield [build] Yields for each form that can be built.
+    # @yieldparam build [::Proc<void>] A block that can be called to build
+    #   a form.
+    # @return [void]
+    def build!(which = :all)
+      return to_enum(:build!, which) unless block_given?
+      @_roots = nil
+      select_forms(which).each { |f| yield proc { f.build(self) } }
+    end
+
+    # A cache for all of the root nodes.  This is a regular hash; however, upon
+    # attempt to access an item that isn't already in the hash, it first
+    # parses the file at that item, and stores the result in the hash, returning
+    # the root node in the file.  This is to cache files so that they do not
+    # get reparsed multiple times.
+    #
+    # @return [{::Pathname => Parser::Root}]
+    def roots
+      @_roots ||= ::Hash.new { |h, k| h[k] = parse_from(k) }
+    end
+
+    # Parses a file.  This bypasses the cache.
+    #
+    # @param path [::Pathname] The path to the actual file.  This should
+    #   respond to `#read`.  If this isn't a pathname, the short should be
+    #   provided.
+    # @param short [::String] The short name of the file.  This is used for
+    #   location information.
+    # @return [Parser::Root]
+    def parse_from(path, short = path.relative_path_from(root))
+      Parser.new(Scanner.new(path.read, short, options).call).call
+    end
+
+  private
+
+    def default_paths
+      sources <<
+        File.expand_path("../../../defaults/source", __FILE__) <<
+        (root / "source")
+      templates <<
+        File.expand_path("../../../defaults/templates", __FILE__) <<
+        (root / "templates")
+    end
+
+    def select_forms(which)
+      which = @forms.map(&:name) if which == :all || !which.is_a?(::Array) ||
+                                    which.empty?
+      which = which.to_set
+      @forms.select { |f| which.include?(f.name) }
+    end
+  end
+end