squared 0.0.1 → 0.0.3

data/lib/squared/config.rb

@@ -9,82 +9,94 @@ module Squared
       include ::Rake::DSL
 
       class << self
-        include Common::Format
-
-        attr_reader :styles
-
-        def style(name, *args)
-          args = check_style(args)
-          styles[name.to_sym]&.clear&.concat(args)
+        def to_s
+          /[^:]+$/.match(super.to_s)[0]
         end
       end
 
-      @styles = {
-        banner: %i[blue],
-        key: %i[bold],
-        value: %i[green],
-        string: %i[yellow],
-        hash: %i[green black!],
-        array: %i[blue black!],
-        number: %i[magenta],
-        undefined: %i[red italic]
-      }.freeze
+      attr_reader :name, :main, :project, :theme
 
-      attr_reader :main, :project, :name
-
-      def initialize(main = 'package', project: nil, name: nil)
+      def initialize(main, name = nil, project: nil, opts: {}, auto: true, common: true)
         if project
-          @project = get(:project)[project.to_sym]
+          main = @project.base_path(main).to_s if (@project = __get__(:project)[project.to_sym])
           @required = true
         end
-        @name = (name || @project&.name)&.to_s
-        unless @name
-          msg, hint = project ? [project, 'not found'] : %w[name missing]
-          warn log_message(:warn, msg, subject: 'Config::Viewer', hint: hint, color: !pipe?)
-          @required = true
+        @name = name&.to_s || @project&.name
+        @ext = File.extname(main)
+        @mime = {}
+        @theme = common ? __get__(:theme)[:viewer] : {}
+        if exist?
+          @main = main.chomp(@ext)
+          @name = @main unless @name || @required
+          if auto
+            case @ext
+            when '.json', '.js'
+              add('json', command: File.basename(@main), opts: opts)
+            when '.yaml', '.yml'
+              add('yaml', command: File.basename(@main), opts: opts)
+            end
+          end
+        else
+          @main = main
         end
-        @main = main
-        @include = {}
+        return unless warning? && ((missing = exist? && !File.exist?(main)) || !@name)
+
+        msg, hint = if missing
+                      ['path not found', realpath]
+                    else
+                      @required = true
+                      project ? [project, 'not found'] : %w[name missing]
+                    end
+        warn log_message(:warn, msg, subject: self.class, hint: hint, color: !pipe?)
       end
 
       def build
         return unless enabled?
 
-        namespace @name do
-          namespace :view do
-            if @include['json'] && !::Rake::Task.task_defined?("#{@name}:view:json")
-              desc format_desc('json')
+        params = ->(args) { exist? ? [realpath, [args.keys] + args.extras] : [args.keys, args.extras] }
+
+        namespace name do
+          view = @command && @command != name ? @command : 'view'
+          namespace view do
+            if @mime['json'] && (exist? || !::Rake::Task.task_defined?("#{name}:#{view}:json"))
+              desc format_desc(view, %w[json])
               task :json, [:keys] do |_, args|
                 require 'json'
-                read_keys JSON, 'json', args.keys, args.extras
+                read_keys(JSON, 'json', *params.(args))
               end
             end
 
-            if @include['yaml'] && !::Rake::Task.task_defined?("#{@name}:view:yaml")
-              desc format_desc('yaml', 'yml')
+            if @mime['yaml'] && (exist? || !::Rake::Task.task_defined?("#{name}:#{view}:yaml"))
+              desc format_desc(view, %w[yaml yml])
               task :yaml, [:keys] do |_, args|
                 require 'yaml'
-                read_keys YAML, 'yaml', args.keys, args.extras, 'yml', 'yaml'
+                read_keys(YAML, 'yaml', *params.(args), ext: %w[yml yaml])
               end
             end
           end
         end
+
+        yield self if block_given?
       end
 
-      def add(type, gem: nil, parse: nil, ext: [], opts: {}, command: nil, file: nil)
+      def add(type, gem: nil, parse: nil, ext: [], opts: {}, command: 'view', file: nil)
+        return self if @mime.frozen?
+
         type = type.to_s
         if parse && enabled?
           require(gem || type)
           obj = eval(parse)
           ext = as_a(ext)
-          namespace @name do
-            desc format_desc(ext.first || type, command: command)
-            namespace(command || :view) do
+          ext << type if ext.empty?
+          file = realpath if file.nil? && exist?
+          namespace name do
+            desc format_desc(command, ext)
+            namespace command do
               task type, [:keys] do |_, args|
                 if file
-                  read_keys obj, type, file.to_s, collect_args(args, :keys), *ext
+                  read_keys(obj, type, file.to_s, collect_args(args, :keys), ext: ext)
                 else
-                  read_keys obj, type, args.keys, args.extras, *ext
+                  read_keys(obj, type, args.keys, args.extras, ext: ext)
                 end
               end
             end
@@ -93,16 +105,19 @@ module Squared
       rescue LoadError, NameError
         self
       else
-        @include[type] = opts
+        @mime[type] = opts
+        if exist?
+          @command = command
+          @mime.freeze
+        end
         self
       end
 
       def also(path, type = nil, name: nil, gem: nil, parse: nil, opts: {})
-        return self unless (file = base_path(path)).exist?
+        return self if @mime.frozen? || !(file = base_path(path)).exist?
 
-        ext = chop_extname(file).downcase
-        name ||= file.basename.to_s.chomp(".#{ext}")
-        type = (type || ext).to_s
+        ext = mime_type(file)
+        type = type&.to_s || ext
         if !parse
           case type
           when 'json'
@@ -112,42 +127,61 @@ module Squared
             parse = 'YAML'
           end
         end
+        name ||= file.basename.to_s.chomp(File.extname(file))
         add(type, gem: gem, parse: parse, ext: ext, opts: opts, command: name, file: file)
       end
 
+      def style(name, *args)
+        apply_style(theme, name, *args)
+        self
+      end
+
+      def extensions
+        exist? ? [@ext.sub('.', '')] : @mime.keys
+      end
+
+      def to_s
+        realpath if exist?
+
+        @mime.keys.map { |ext| "#{main}.#{ext}" }.join(',')
+      end
+
+      def inspect
+        "#<#{self.class}: #{name} => #{exist? ? realpath : "#{main} {#{extensions.join(', ')}}"}>"
+      end
+
       def enabled?
-        !@required || !!@project&.enabled?
+        return File.exist?(realpath) if exist?
+
+        !@required || (!project.nil? && project.enabled?)
       end
 
       protected
 
-      def read_keys(reader, type, file, keys, *ext)
-        path = base_path(file)
-        fmt = chop_extname(file)
-        ext << type if ext.empty?
-        if path.exist? && path.basename.to_s.include?('.')
-          raise ArgumentError, message(file, fmt, hint: 'invalid') unless ext.include?(fmt)
+      def read_keys(reader, type, file, keys, ext: [type])
+        if (mime = mime_type(file)) && base_path(file).exist?
+          raise ArgumentError, message(file, mime, hint: 'invalid') unless ext.include?(mime)
         else
-          if ext.include?(fmt)
+          if ext.include?(mime)
             alt = file
             file = nil
-            ext[0] = fmt
+            ext[0] = mime
           else
             keys.unshift(file)
-            alt = "#{@main}.{#{ext.join(',')}}"
-            alt = @project.base_path(alt) if @project
+            alt = base_path("#{main}.{#{ext.join(',')}}")
             file = Dir[alt].first
           end
-          if !file
+          unless file
             raise ArgumentError, message(reader.name, "#{File.basename(alt, '.*')}.#{ext.first}", hint: 'not found')
           end
         end
+        project&.info "#{Viewer}(#{type}) => #{file} {#{keys.join(', ')}}"
         doc = if reader.respond_to?(:load_file)
-                reader.load_file(file, **@include[type])
+                reader.load_file(file, **@mime[type])
               else
-                reader.parse(File.read(file), **@include[type])
+                reader.parse(File.read(file), **@mime[type])
               end
-        lines = print_keys(type, doc, keys)
+        lines = print_keys(type, doc, keys, file: file)
         return unless lines
 
         title = Pathname.new(file)
@@ -157,24 +191,25 @@ module Squared
         sub = if pipe?
                 nil
               else
+                styles = theme
                 [
-                  { pat: /^([^:]+|(?<! ):(?! ))+$/, styles: Viewer.styles[:banner] },
-                  { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: Viewer.styles[:undefined], index: 2 },
-                  { pat: /^(.+)( : (?!undefined))(.+)$/m, styles: Viewer.styles[:key] },
-                  { pat: /^(.+)( : )(-?[\d.]+)(\s*)$/m, styles: Viewer.styles[:number], index: 3 },
-                  { pat: /^(.+)( : ")(.+)("\s*)$/m, styles: Viewer.styles[:string], index: 3 },
-                  { pat: /^(.+)( : \{)(.+)(\}\s*)$/m, styles: Viewer.styles[:hash], index: 3 },
-                  { pat: /^(.+)( : \[)(.+)(\]\s*)$/m, styles: Viewer.styles[:array], index: 3 },
-                  { pat: /^(.+)( : (?!undefined))([^"\[{].*)$/m, styles: Viewer.styles[:value], index: 3 }
+                  { pat: /^((?:[^:]|(?<! ):(?! ))+)$/, styles: styles[:banner] },
+                  { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: styles[:undefined], index: 2 },
+                  { pat: /^(.+)( : (?!undefined).+)$/m, styles: styles[:key] },
+                  { pat: /^(.+ : )(-?[\d.]+)(\s*)$/m, styles: styles[:number], index: 2 },
+                  { pat: /^(.+ : ")(.+)("\s*)$/m, styles: styles[:string], index: 2 },
+                  { pat: /^(.+ : \{)(.+)(\}\s*)$/m, styles: styles[:hash], index: 2 },
+                  { pat: /^(.+ : \[)(.+)(\]\s*)$/m, styles: styles[:array], index: 2 },
+                  { pat: /^(.+ : (?!undefined))([^"\[{].*)$/m, styles: styles[:value], index: 2 }
                 ]
               end
         emphasize(lines, title: title, sub: sub)
       end
 
-      def print_keys(type, data, keys)
+      def print_keys(type, data, keys, file: nil)
         out = []
         pad = 0
-        symbolize = @include[type][:symbolize_names]
+        symbolize = @mime[type][:symbolize_names]
         keys.each do |key|
           begin
             items = key.split('.')
@@ -189,6 +224,7 @@ module Squared
               end
             end
           rescue StandardError
+            project&.warn "#{Viewer}(#{type}) => #{file ? "#{file} " : ''}{#{key}: undefined}"
             val = Regexp.escape($!.message)
             key = key.sub(/(#{val})\.|\.(#{val})|(#{val})/) do
               s = "<#{$3 || $2 || $1}>"
@@ -198,41 +234,59 @@ module Squared
                 $2 ? ".#{s}" : "#{s}."
               end
             end
-            out << [key, 'undefined']
+            out << [key, pipe? ? nil : 'undefined']
           else
-            out << [key, val.inspect]
+            out << [key, pipe? ? val : val.inspect]
           end
           pad = key.size if key.size > pad
         end
         if pipe?
-          out = out.map do |item|
-            val = item.last
-            val.start_with?('"') && val.end_with?('"') ? val[1..-2] : val
-          end
+          require 'json'
+          out = out.map { |item| JSON.dump(item[1]) }
           puts out.join("\n")
         else
-          out.map { |item| "#{item.first.ljust(pad)} : #{item.last}" }
+          out.map { |item| "#{item[0].ljust(pad)} : #{item[1]}" }
         end
       end
 
       def base_path(file)
-        @project ? @project.base_path(file) : Pathname.new(file).realdirpath
+        project ? project.base_path(file) : Pathname.new(file).realdirpath
       end
 
-      def format_desc(type, alt = nil, command: nil)
-        message(@name, command || 'view', "#{type}[#{command.nil? ? "file?=#{@main}.#{alt || type}," : ''}keys*]")
+      def mime_type(file)
+        case (ret = File.extname(file).sub('.', '').downcase)
+        when 'yml'
+          'yaml'
+        when 'js'
+          'json'
+        else
+          ret.empty? ? nil : ret
+        end
+      end
+
+      def format_desc(command, ext)
+        message(name, command, "#{ext.first}[#{exist? ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys*]")
       end
 
-      def chop_extname(file)
-        File.extname(file).sub('.', '')
+      def realpath
+        file = main + @ext
+        Pathname.new(file).realdirpath.to_s rescue file
+      end
+
+      def exist?
+        !@ext.empty? && (!@required || !project.nil?)
       end
 
       def pipe?
-        return @project.workspace.pipe? if @project
+        return project.workspace.pipe if project
 
         val = ENV['PIPE_OUT']
         !val.nil? && !val.empty? && val != '0'
       end
+
+      def warning?
+        project ? project.warning : true
+      end
     end
   end
 end