squared 0.0.9 → 0.0.11

data/lib/squared/workspace/project/node.rb

@@ -1,61 +1,57 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Squared
   module Workspace
     module Project
       class Node < Git
+        include Common::Prompt
+
         class << self
           def populate(*); end
 
           def tasks
-            nil
+            %i[outdated].freeze
+          end
+
+          def batchargs
+            [ref, { refresh: %i[build copy] }]
+          end
+
+          def aliasargs
+            [ref, { refresh: :build }]
           end
 
           def prod?
             ENV['NODE_ENV'] == 'production'
           end
 
-          def is_a?(val)
-            if (val = as_path(val))
-              val.join('package.json').exist?
-            else
-              super
-            end
+          def config?(val)
+            return false unless (val = as_path(val))
+
+            val.join('package.json').exist?
           end
         end
 
         @@tasks[ref] = {
-          install: %i[force frozen dedupe],
-          outdated: %i[major minor patch],
+          install: %i[force frozen dedupe].freeze,
+          outdated: %i[major minor patch].freeze,
+          bump: %i[major minor patch].freeze,
           run: nil
         }.freeze
 
         attr_reader :package
 
-        def initialize(*, script: nil, **kwargs)
+        def initialize(*, **kwargs)
           super
-          initialize_script(Node.ref, **kwargs)
-          @dev = kwargs[:dev]
-          @prod = kwargs[:prod]
+          if @pass.include?(Node.ref)
+            initialize_ref(Node.ref)
+            initialize_logger(**kwargs)
+          else
+            initialize_build(Node.ref, prod: prod?, **kwargs)
+            initialize_env(**kwargs)
+          end
           @pm = {}
           @package = base_path('package.json')
-          return if @output[0] == false
-
-          if @output[0].nil?
-            val, ext = @workspace.script(Node.ref, @group)
-            script_set val
-            unless ext
-              if script
-                script_set script
-              elsif (val = @script && @script[:run])
-                @output[0] = val
-                @output[1] = nil
-              end
-            end
-          end
-          @output[@output[0] || val.include?(' ') ? 0 : 1] = val if (val = env('BUILD', strict: true))
         end
 
         def ref
@@ -71,11 +67,55 @@ module Squared
               if flags.nil?
                 case action
                 when :run
-                  desc format_desc(action, nil, 'command+')
+                  desc format_desc(action, nil, 'command+|^index|#,pattern*')
                   task action, [:command] do |_, args|
-                    cmd = args.to_a
-                    guard_params(action, 'command', args: cmd)
-                    run_script cmd
+                    if args.command == '#'
+                      list = read_scripts
+                      grep = args.extras.map { |val| Regexp.new(val) }
+                      lines = []
+                      if (pad = list.size) > 0
+                        pad = pad.to_s.size
+                        list.each_with_index do |val, i|
+                          next unless grep.empty? || grep.any? { |pat| pat.match?(val[0]) }
+
+                          lines << "#{(i + 1).to_s.rjust(pad)}. #{val[0]}"
+                        end
+                      end
+                      if lines.empty?
+                        lines = ['No scripts were found:', '']
+                        unless args.extras.empty?
+                          i = 0
+                          lines += args.extras.to_a.map { |s| "#{i += 1}. #{s}" }
+                          lines << ''
+                        end
+                        lines << package.to_s
+                        pat = /^(#{Regexp.escape(lines.last)})(.*)$/
+                      else
+                        pat = /^(\s*\d+\.)(.+)$/
+                      end
+                      emphasize(lines, title: task_join(name, 'run[^N]'), border: borderstyle, sub: [
+                        headerstyle,
+                        { pat: pat, styles: theme[:active] }
+                      ])
+                    else
+                      cmd = args.to_a
+                      guard_params(action, 'command', args: cmd)
+                      list = nil
+                      cmd.each do |val|
+                        if (data = /\A\^(\d+)\z/.match(val))
+                          list ||= read_scripts
+                          n = data[1].to_i
+                          if (item = list[n - 1])
+                            val = item.first
+                          elsif exception
+                            raise_error("requested index #{n}", hint: "total #{list.size}")
+                          else
+                            next log.warn "run script #{n} of #{list.size} (out of range)"
+                          end
+                        end
+                        run compose(val, script: true)
+                      end
+                    end
                   end
                 end
               else
@@ -88,10 +128,15 @@ module Squared
                         depend(flag)
                       end
                     when :outdated
-                      desc format_desc(action, flag, %w[prune interactive dry-run], arg: 'opts?')
+                      desc format_desc(action, flag, %w[prune interactive dry-run].freeze, arg: 'opts?')
                       task flag, [:opts] do |_, args|
                         outdated(flag, opts: args.to_a)
                       end
+                    else
+                      desc format_desc(action, flag)
+                      task flag do
+                        __send__(action, flag)
+                      end
                     end
                   end
                 end
@@ -100,20 +145,21 @@ module Squared
           end
         end
 
-        def copy(from: 'build', glob: '**/*', subdir: 'node_modules', into: nil, also: [], override: false)
+        def copy(from: 'build', glob: '**/*', into: 'node_modules', scope: nil, also: nil, override: false)
           if @copy && !override
-            return super if @copy.is_a?(::String)
+            return super if runnable?(@copy)
 
             from = @copy[:from] if @copy.key?(:from)
             glob = @copy[:glob] if @copy.key?(:glob)
-            subdir = @copy[:subdir] if @copy.key?(:subdir)
             into = @copy[:into] if @copy.key?(:into)
+            scope = @copy[:scope] if @copy.key?(:scope)
             also = @copy[:also] if @copy.key?(:also)
           end
-          items = [name == workspace.main ? nil : workspace.home].concat(as_a(also))
+          items = [path != workspace.home && workspace.home? ? workspace.home : nil]
+          items += as_a(also) if also
           items.each_with_index do |dir, i|
             if i == 0
-              next unless dev? & !doc?
+              next unless dev? && build?
 
               dest = dir
             else
@@ -123,16 +169,19 @@ module Squared
               when ::Symbol
                 dest = Workspace.resolve(dir)&.path
               when ::Hash
-                into = nil
-                glob = nil
+                glob = '**/*'
+                dest = nil
+                scope = nil
                 dir.each do |key, val|
                   case key.to_sym
+                  when :target
+                    dest = val
                   when :from
                     from = val
                   when :glob
                     glob = val
-                  when :subdir
-                    subdir = val
+                  when :scope
+                    scope = val
                   when :into
                     into = val
                   end
@@ -140,18 +189,17 @@ module Squared
               when Project::Base
                 dest = dir.path
               end
-              next unless into
             end
             next unless dest&.directory?
 
             from = base_path(from)
-            dest = dest.join(subdir, into || project)
-            log.warn "cp #{from.join(glob)} #{dest}"
-            copy_d(from, dest, glob: glob, verbose: verbose?)
+            dest = dest.join(into, scope || project)
+            (glob = as_a(glob)).each { |val| log.info "cp #{from.join(val)} #{dest}" }
+            copy_d(from, dest, glob: glob, verbose: verbose)
           end
         end
 
-        def depend(flag = nil)
+        def depend(flag = nil, sync: invoked_sync?('depend', flag))
           if @depend && !flag
             super
           elsif outdated?
@@ -173,8 +221,8 @@ module Squared
                                     elsif flag == :frozen
                                       '--frozen-lockfile'
                                     end
-                cmd << '--production' if prod?
-                cmd << '--ignore-engines' unless env('YARN_IGNORE_ENGINES', equals: '0')
+                cmd << '--production' if flag && prod?
+                cmd << '--ignore-engines' unless option('ignore-engines', equals: '0')
               end
             elsif pnpm?
               cmd = session 'pnpm'
@@ -187,9 +235,12 @@ module Squared
                                       '--frozen-lockfile'
                                     end
               end
-              cmd << '--prod' if prod?
+              cmd << '--prod' if flag && prod?
+              if (val = option('public-hoist-pattern', ignore: false))
+                split_escape(val).each { |opt| cmd << "--public-hoist-pattern=#{shell_escape(opt, quote: true)}" }
+              end
               cmd << '--ignore-workspace' if env('NODE_WORKSPACES', equals: '0')
-              append_nocolor
+              append_nocolor option('no-color')
             else
               cmd = session 'npm'
               if flag == :dedupe
@@ -201,60 +252,73 @@ module Squared
                                       '--package-lock-only'
                                     end
               end
-              cmd << '--omit=dev' if prod?
+              cmd << '--omit=dev' if flag && prod?
               cmd << '--workspaces=false' if env('NODE_WORKSPACES', equals: '0')
-              cmd << '--package-lock=false' if env('NPM_PACKAGE_LOCK', equals: '0')
-              append_nocolor
+              cmd << '--package-lock=false' if option('package-lock', equals: '0')
+              append_nocolor option('no-color')
             end
             append_loglevel
-            run(sync: invoked_sync?('depend', flag))
+            run(sync: sync)
           end
         end
 
         def outdated(rev = nil, opts: [])
-          equ = rev || (prod? ? :patch : :minor)
-          cmd = pnpm? ? 'pnpm outdated' : 'npm outdated'
+          dryrun = opts.include?('dry-run')
+          if pnpm? && read_packagemanager(version: '7.15')
+            cmd = 'pnpm outdated'
+            dryrun ||= !option('dry-run', prefix: 'pnpm').nil?
+          else
+            cmd = 'npm outdated'
+            dryrun ||= !option('dry-run', prefix: 'npm').nil?
+          end
           log.info cmd
-          if store_pwd || invoked_sync?("outdated#{rev && ":#{rev}"}")
-            print_item format_banner("#{cmd}#{opts.include?('dry-run') ? ' --dry-run' : ''}", multiple: true)
+          banner = format_banner("#{cmd}#{dryrun ? ' --dry-run' : ''}", multiple: true)
+          if invoked_sync?('outdated', rev)
+            print_item banner
+            banner = nil
           end
-          data = `#{cmd} --json --loglevel=error`
-          store_pwd true
+          data = nil
+          pwd_set { data = `#{cmd} --json --loglevel=error` }
           json = JSON.parse(doc = package.read)
           dep1 = json['dependencies'] || {}
           dep2 = json['devDependencies'] || {}
           found = []
           avail = []
-          if !data.empty?
+          rev ||= (prod? ? :patch : :minor)
+          inter = opts.include?('interactive')
+          unless data.empty?
             JSON.parse(data).each_pair do |key, val|
-              val = val.find { |item| item['dependent'] == json['name'] } if val.is_a?(Array)
-              next unless val && (file = dep1[key] || dep2[key])
+              val = val.find { |obj| obj['dependent'] == json['name'] } if val.is_a?(::Array)
+              next unless val && (file = dep1[key] || dep2[key]) && file != '*'
 
+              latest = val['latest']
               ch = file[0]
-              unless ch =~ /[~^]/
-                avail << [key, file, val['latest'], true]
+              if ch =~ /[~^]/
+                file = file[1..-1]
+              elsif inter && rev == :major
+                major = true
+              else
+                avail << [key, file, latest, true]
                 next
               end
-              file = file[1..-1]
-              cur = val['current']
-              want = if equ == :major && val['latest'] =~ SEM_VER
-                       [val['latest'], val['wanted']].max { |a, b| a <=> b }
-                     else
-                       val['wanted']
-                     end
-              next unless (cur != want || file != want) && (want.match?(SEM_VER) || !file.match?(SEM_VER))
-
-              a, b = file.split('.')
-              c, d, e = want.split('.')
-              case equ
+              want = rev == :major && (ver = latest.match(SEM_VER)) && !ver[6] ? latest : val['wanted']
+              next unless (val['current'] != want || file != want) && (want.match?(SEM_VER) || !file.match?(SEM_VER))
+
+              f = semver(semscan(file))
+              w = semver(semscan(want))
+              a = f[0]
+              b = f[2]
+              c = w[0]
+              d = w[2]
+              case rev
               when :major
                 upgrade = a == '0' ? c == '0' : true
               when :minor
                 upgrade = ch == '^' && (a == '0' ? c == '0' && b == d : a == c)
               when :patch
-                upgrade = a == c && b == d && !e.nil?
+                upgrade = a == c && b == d && f[4] != w[4]
               end
-              if upgrade
+              if upgrade && !w[5]
                 next if file == want
 
                 index = if a != c
@@ -264,9 +328,9 @@ module Squared
                         else
                           5
                         end
-                found << [key, file, want, index]
-              else
-                avail << [key, file, val['latest'], false]
+                found << [key, file, want, index, major, f, w]
+              elsif !major
+                avail << [key, file, latest, false]
               end
             end
           end
@@ -278,7 +342,7 @@ module Squared
             ord.size > 9 ? ret.rjust(ord.size.to_s.size) : ret
           end
           footer = lambda do |val = 0|
-            next unless verbose?
+            next unless verbose
 
             msg, hint = if modified == -1
                           ['Packages were updated', 'more possible']
@@ -287,25 +351,24 @@ module Squared
                         end
             puts print_footer(empty_status(msg, hint, pending + val))
           end
+          print_item banner if banner
           if !found.empty?
             col1 = size_col.(found, 0) + 4
             col2 = size_col.(found, 1) + 4
-            inter = opts.include?('interactive')
             found.each_with_index do |item, i|
-              a, b, c, d = item
-              prompt = inter && (equ != :major || semmajor(semver(b.scan(SEM_VER)[0]), semver(c.scan(SEM_VER)[0])))
-              if prompt && !confirm_outdated(equ.upcase, a, c)
+              a, b, c, d, e = item
+              if inter && (rev != :major || e || semmajor(item[5], item[6])) && !confirm_outdated(a, c, d, e)
                 cur = -1
               else
                 cur = modified
-                doc.sub!(/("#{Regexp.escape(a)}"\s*:\s*)"([~^])#{Regexp.escape(b)}"/) do |capture|
-                  if $2 == '~' && equ != :patch
+                doc.sub!(/("#{Regexp.escape(a)}"\s*:\s*)"([~^])#{e ? '?' : ''}#{Regexp.escape(b)}"/) do |capture|
+                  if $2 == '~' && rev != :patch
                     cur = -1
                     pending += 1
                     capture
                   else
                     modified += 1
-                    "#{$1}\"#{$2 || ''}#{c}\""
+                    "#{$1}\"#{$2 || (d == 1 && e ? '^' : '')}#{c}\""
                   end
                 end
               end
@@ -316,14 +379,14 @@ module Squared
                     'FAIL'
                   elsif d == 1
                     a = sub_style(a, styles: theme[:major])
-                    sub_style(c, :green, :bold)
+                    sub_style(c, :bold, styles: color(:green))
                   else
-                    sub_style(c, :green, pat: SEM_VER, index: d)
+                    sub_style(c, pat: SEM_VER, styles: color(:green), index: d)
                   end
               puts "#{pad_ord.(i, found)}. #{a}#{b.ljust(col2)}#{c}"
             end
             pending = avail.reduce(pending) { |a, b| a + (b[3] ? 0 : 1) }
-            if opts.include?('dry-run') || (modified == 0 && pending > 0)
+            if dryrun || (modified == 0 && pending > 0)
               footer.(modified)
             elsif modified > 0
               File.write(package, doc)
@@ -339,11 +402,11 @@ module Squared
             avail.each_with_index do |item, i|
               a, b, c, d = item
               a = a.ljust(col1)
-              b = sub_style(b.ljust(col2), d ? :red : :yellow)
+              b = sub_style(b.ljust(col2), styles: color(d ? :red : :yellow))
               c = c.ljust(col3)
               unless d
                 a = sub_style(a, styles: theme[:active])
-                c = sub_style(c, :green)
+                c = sub_style(c, styles: color(:green))
                 pending += 1
               end
               puts "#{pad_ord.(i, avail)}. #{a + c + b} (#{d ? 'locked' : 'latest'})"
@@ -354,23 +417,75 @@ module Squared
           end
         end
 
-        def compose(args)
-          args ||= @output[1]
-          cmd = [if yarn?
-                   'yarn'
-                 else
-                   pnpm? ? 'pnpm' : 'npm'
-                 end]
-          cmd << 'run'
-          append_loglevel cmd
-          if args.is_a?(::Array)
-            cmd += args
-          elsif args.is_a?(::String)
-            cmd << args
+        def compose(opts, flags = nil, script: false)
+          return unless opts && script
+
+          ret = session (if yarn?
+                           'yarn'
+                         else
+                           pnpm? ? 'pnpm' : 'npm'
+                         end), 'run', flags
+          append_loglevel
+          case opts
+          when ::Enumerable
+            ret += opts.to_a
+          when ::String
+            ret << opts
           else
-            raise_error("#{cmd.first} script name", hint: args.nil? ? 'missing' : 'invalid')
+            raise_error("#{ret.first} script name", hint: opts.nil? ? 'missing' : 'invalid')
+          end
+          ret
+        end
+
+        def bump(flag)
+          return unless (ver = version)
+
+          seg = semscan(ver)
+          case flag
+          when :major
+            if seg[0] != '0' || seg[2].nil?
+              seg[0] = seg[0].succ
+            else
+              seg[2] = seg[2].succ
+            end
+          when :minor
+            if seg[0] == '0'
+              seg[4] &&= seg[4].succ
+            else
+              seg[2] = seg[2].succ
+            end
+          when :patch
+            seg[4] &&= seg[4].succ
+          end
+          unless (out = seg.join) == ver
+            begin
+              doc = package.read
+              if doc.sub!(/"version"\s*:\s*"#{ver}"/, "\"version\": \"#{out}\"")
+                package.write(doc)
+                log.info "bump version #{ver} to #{out} (#{flag})"
+                if verbose
+                  major = flag == :major
+                  emphasize("version: #{out}", title: name, border: borderstyle, sub: [
+                    headerstyle,
+                    { pat: /^(version:)( )(\S+)(.*)$/, styles: color(major ? :green : :yellow), index: 3 },
+                    { pat: /^(version:)(.*)$/, styles: theme[major ? :major : :active] }
+                  ])
+                elsif stdin?
+                  puts out
+                end
+              else
+                raise_error('not found', hint: 'version')
+              end
+            rescue StandardError => e
+              log.debug e
+              raise
+            end
           end
-          cmd.join(' ')
+        end
+
+        def version
+          read_packagemanager
+          @pm[:version]
         end
 
         def install_type(prog = nil)
@@ -380,12 +495,12 @@ module Squared
           @pm[prog] || 0
         end
 
-        def build?
-          @output[0] != false && (!@output[0].nil? || !@output[1].nil?)
+        def depend?
+          @depend != false && (!@depend.nil? || outdated?)
         end
 
         def copy?
-          !!@copy
+          super || @copy.is_a?(::Hash)
         end
 
         def outdated?
@@ -393,8 +508,8 @@ module Squared
         end
 
         def yarn?
-          (@pm[:yarn] ||= if File.exist?(base_path('yarn.lock'))
-                            if File.exist?(rc = base_path('.yarnrc.yml'))
+          (@pm[:yarn] ||= if base_path('yarn.lock', ascend: find_package).exist?
+                            if (rc = base_path('.yarnrc.yml', ascend: find_package)).exist?
                               begin
                                 require 'yaml'
                                 doc = YAML.load_file(rc)
@@ -405,7 +520,7 @@ module Squared
                             else
                               1
                             end
-                          elsif (ver = read_packagemanager || env('NODE_INSTALL')) && ver.start_with?('yarn')
+                          elsif (ver = read_packagemanager || read_install) && ver.start_with?('yarn')
                             ver == 'yarn' || ver.include?('@1') ? 1 : 3
                           else
                             0
@@ -413,10 +528,11 @@ module Squared
         end
 
         def pnpm?
-          (@pm[:pnpm] ||= if File.exist?(base_path('pnpm-lock.yaml'))
+          (@pm[:pnpm] ||= if base_path('pnpm-lock.yaml', ascend: find_package).exist?
                             begin
                               require 'yaml'
-                              doc = YAML.load_file(base_path('node_modules/.modules.yaml'))
+                              doc = YAML.load_file(base_path('node_modules/.modules.yaml', ascend: find_package))
+                              @pm[:_] = doc['packageManager']
                               case doc['nodeLinker']
                               when 'hoisted'
                                 1
@@ -429,86 +545,116 @@ module Squared
                               4
                             end
                           else
-                            (read_packagemanager || env('NODE_INSTALL'))&.start_with?('pnpm') ? 4 : 0
+                            (read_packagemanager || read_install)&.start_with?('pnpm') ? 4 : 0
                           end) > 0
         end
 
+        def workspaces?
+          if pnpm?
+            base_path('pnpm-workspace.yaml').exist?
+          else
+            read_packagemanager
+            @pm[:workspaces].is_a?(::Array)
+          end
+        end
+
         def dev?
-          !Node.prod? && workspace.dev?(pat: @dev, **runargs)
+          !Node.prod? && super
         end
 
         def prod?
-          Node.prod? || workspace.prod?(pat: @prod, **runargs)
+          @prod != false && (Node.prod? || super)
         end
 
         private
 
-        def run_script(cmd)
-          cmd.each { |val| run_s compose(val) }
+        def read_packagemanager(version: nil)
+          if @pm[:_].nil?
+            doc = JSON.parse(package.read)
+            @pm[:_] = (val = doc['packageManager']) ? val[0..(val.index('+') || 0) - 1] : false
+            @pm[:scripts] = doc['scripts']
+            @pm[:version] = doc['version']
+            @pm[:workspaces] = doc['workspaces']
+          end
+        rescue StandardError => e
+          log.debug e if package.exist?
+          @pm[:_] = false
+          nil
+        else
+          return if !@pm[:_] || (version && @pm[:_][@pm[:_].index('@') + 1..-1] < version)
+
+          @pm[:_]
+        end
+
+        def read_install
+          return unless (ret = env('NODE_INSTALL'))
+
+          @pm[:_] ||= ret if ret.include?('@')
+          ret
         end
 
-        def append_loglevel(cmd = @session)
-          return unless (level = env('NODE_LOGLEVEL'))
+        def read_scripts
+          read_packagemanager
+          @pm[:scripts].is_a?(Hash) ? @pm[:scripts].to_a : []
+        end
+
+        def append_loglevel
+          level = env('NODE_LOGLEVEL')
+          silent = !verbose || level == 'silent'
+          return unless silent || level
 
-          silent = !workspace.verbose || level == 'silent'
           if yarn?
             if install_type(:yarn) == 1
               if silent
-                cmd << '--silent'
+                @session << '--silent'
               elsif level == 'verbose'
-                cmd << '--verbose'
+                @session << '--verbose'
               end
             end
           elsif pnpm?
             if silent
-              cmd << '--reporter=silent'
+              @session << '--reporter=silent'
               level ||= 'error'
             end
             case level
             when 'debug', 'info', 'warn', 'error'
-              cmd << "--loglevel=#{level}"
+              @session << "--loglevel=#{level}"
             end
           elsif silent
-            cmd << '--loglevel=silent'
+            @session << '--loglevel=silent'
           else
             case level
             when 'error', 'warn', 'notice', 'http', 'info', 'verbose', 'silly'
-              cmd << "--loglevel=#{level}"
+              @session << "--loglevel=#{level}"
             end
           end
         end
 
-        def confirm_outdated(rev, pkg, ver)
-          m = ver == :major
-          confirm("Upgrade to #{rev}? #{sub_style("#{pkg} #{ver}", styles: theme[:inline])} [#{m ? 'y/N' : 'Y/n'}] ",
-                  default: m ? 'N' : 'Y', timeout: 60)
-        end
-
-        def read_packagemanager
-          if @pm[:_].nil?
-            doc = JSON.parse(package.read)
-            @pm[:_] = (val = doc['packageManager']) ? val[0..(val.index('+') || 0) - 1] : false
-          end
-        rescue StandardError => e
-          log.warn e if package.exist?
-          @pm[:_] = false
-          nil
-        else
-          @pm[:_] || nil
+        def confirm_outdated(pkg, ver, rev, lock)
+          a = sub_style(case rev
+                        when 1
+                          'MAJOR'
+                        when 3
+                          'MINOR'
+                        else
+                          'PATCH'
+                        end, styles: theme[:header])
+          b = sub_style("#{pkg} #{ver}", styles: theme[:inline])
+          c, d = rev == 1 || lock ? ['y/N', 'N'] : ['Y/n', 'Y']
+          e = lock ? " #{sub_style('(locked)', styles: color(:red))}" : ''
+          confirm("Upgrade to #{a}? #{b}#{e} [#{c}] ", d, timeout: 60)
         end
 
-        def script_set(val)
-          @output[1] = if val.is_a?(::Array)
-                         val[Node.prod? ? 1 : 0]
-                       else
-                         val
-                       end
+        def find_package
+          'package.json' if parent&.has?('outdated', Node.ref)
         end
 
-        def runargs
-          { script: @output[1], ref: Node.ref, group: group, global: @output[0].nil? && !(@script && @script[:run]) }
+        def headerstyle
+          { pat: /^(\S+)(\s+)$/, styles: theme[:header] }
         end
       end
+
+      Application.implement Node
     end
   end
 end