squared 0.1.3 → 0.2.0

data/lib/squared/common/utils.rb

@@ -9,7 +9,7 @@ module Squared
       module_function
 
       def task_invoke(*cmd, args: [], exception: true, warning: true)
-        cmd.each { |name| ::Rake::Task[name].invoke(*args) }
+        cmd.each { |name| Rake::Task[name].invoke(*args) }
       rescue StandardError => e
         raise if exception
 
@@ -28,10 +28,10 @@ module Squared
       end
 
       def task_invoked?(*args)
-        ::Rake::Task.tasks.any? do |obj|
+        Rake::Task.tasks.any? do |obj|
           next unless obj.already_invoked
 
-          args.any? { |val| val.is_a?(::Regexp) ? val.match?(obj.name) : val == obj.name }
+          args.any? { |val| val.is_a?(::Regexp) ? obj.name =~ val : val == obj.name }
         end
       end
 
@@ -64,7 +64,7 @@ module Squared
       def env_pipe(key, default = 1, suffix: nil, root: nil)
         if default.is_a?(::String)
           begin
-            default = (root ? root.join(default) : ::Pathname.new(default)).realdirpath
+            default = (root ? root.join(default) : Pathname.new(default)).realdirpath
           rescue StandardError => e
             default = 1
             warn e
@@ -91,7 +91,7 @@ module Squared
         when '1'
           true
         else
-          ::Regexp.new(ret, options, timeout: timeout)
+          Regexp.new(ret, options, timeout: timeout)
         end
       end
     end

data/lib/squared/config.rb

@@ -11,41 +11,77 @@ module Squared
       include Utils
       include Rake::DSL
 
-      def self.to_s
-        super.match(/[^:]+\z/)[0]
+      class << self
+        def parse(gem, namespace, ext = [pkg])
+          require gem
+          obj = eval(namespace)
+          ext = [ext] unless ext.is_a?(Array)
+          ext.each { |val| @@mime_obj[val] = [obj, ext] }
+        rescue LoadError, NameError => e
+          warn e
+          nil
+        else
+          @@mime_obj[ext.first]
+        end
+
+        def link(project, main = project.dependfile.basename, name = nil, **kwargs, &blk)
+          return unless project.enabled?
+
+          ret = Viewer.new(main, name, project: project, **kwargs)
+          ret.instance_eval(&blk) if block_given?
+          ret
+        end
+
+        def to_s
+          super.match(/[^:]+\z/)[0]
+        end
       end
 
+      @@mime_obj = {}
+      @@task_desc = Rake::TaskManager.record_task_metadata
+
       attr_reader :main, :name, :project, :theme
       attr_accessor :pipe
 
-      def initialize(main, name = nil, project: nil, prefix: nil, dump: nil, opts: {}, auto: true,
+      def initialize(main, name = nil, project: nil, prefix: nil, command: nil, dump: nil, opts: {}, auto: true,
                      common: ARG[:COMMON], pipe: ARG[:PIPE], **)
-        if project
-          main = @project.basepath(main).to_s if (@project = __get__(:project)[project.to_s])
+        if project && (project.respond_to?(:workspace) || (project = __get__(:project)[project.to_s]))
+          main = project.basepath(main).to_s
+          @project = project
           @required = true
         end
-        @name = name&.to_s || @project&.name
-        @prefix = prefix
-        @ext = File.extname(main).downcase
+        @name = name || @project&.name
+        @prefix = prefix unless @project
+        @ext = File.extname(main)
         @dump = dump
         @mime = {}
         @theme = common ? __get__(:theme)[:viewer] : {}
         @pipe = env_pipe(pipe, @project ? @project.pipe : 1)
-        if exist?
+        if target?
           @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)
+            unless command
+              command = File.basename(@main)
+              command = ARG[:VIEW] if command == @name
+            end
+            ext = @ext[1..-1].downcase
+            if (data = @@mime_obj[ext])
+              add(data[1].first, command: command, opts: opts, ext: data[1])
+            else
+              case ext
+              when 'json', 'js'
+                add('json', command: command, opts: opts)
+              when 'yaml', 'yml'
+                add('yaml', command: command, opts: opts)
+              end
             end
           end
         else
           @main = main
+          @command = command || ARG[:VIEW]
         end
-        return unless warning? && ((missing = exist? && !File.exist?(main)) || !@name)
+        return unless warning? && ((missing = target? && !File.exist?(main)) || !@name)
 
         msg, hint = if missing
                       ['path not found', realpath]
@@ -60,21 +96,24 @@ module Squared
         return unless enabled?
 
         namespace(ns = task_name(name)) do
-          view = @command && @command != name ? @command : 'view'
-          params = ->(args) { exist? ? [realpath, [args.keys] + args.extras] : [args.keys, args.extras] }
-          namespace view do
-            if @mime['json'] && (exist? || !Rake::Task.task_defined?("#{ns}:#{view}:json"))
-              desc format_desc(view, 'json')
-              task 'json', [:keys] do |_, args|
-                read_keys(JSON, 'json', *params.(args))
-              end
-            end
+          @mime.each do |type, items|
+            items.each do |command, file, opts|
+              next if Rake::Task.task_defined?("#{ns}:#{command}:#{type}")
+
+              namespace command do
+                unless (data = @@mime_obj[type])
+                  ext = [type]
+                  ext << 'yml' if type == 'yaml'
+                  next unless (data = Viewer.parse(type, type.upcase, ext))
+                end
+                obj, ext = data
+                target = file || target? ? file || realpath : nil
 
-            if @mime['yaml'] && (exist? || !Rake::Task.task_defined?("#{ns}:#{view}:yaml"))
-              desc format_desc(view, 'yaml', 'yml')
-              task 'yaml', [:keys] do |_, args|
-                require 'yaml'
-                read_keys(YAML, 'yaml', *params.(args), ext: ['yml', 'yaml'])
+                task_desc(command, *ext, target: target)
+                task type, [:keys] do |_, args|
+                  params = target ? [target, args.to_a] : [args.keys, args.extras]
+                  read_keys(obj, ext.first, *params, ext: ext, opts: opts)
+                end
               end
             end
           end
@@ -82,57 +121,52 @@ module Squared
         yield self if block_given?
       end
 
-      def add(type, gem: nil, parse: nil, ext: nil, opts: {}, command: 'view', file: nil, exist: nil)
+      def add(type, ext: nil, opts: {}, command: ARG[:VIEW], gem: nil, namespace: nil, file: nil)
         return self if @mime.frozen?
 
-        type = type.to_s
-        if parse && enabled?
-          require(gem || type)
-          obj = eval(parse)
-          ext << type if (ext = as_a(ext)).empty?
-          file = realpath if !file && exist?
-
-          namespace task_name(name) do
-            namespace command do
-              desc format_desc(command, *ext, exist: exist)
-              task type, [:keys] do |_, args|
-                if file
-                  read_keys(obj, type, file.to_s, args.to_a, ext: ext)
-                else
-                  read_keys(obj, type, args.keys, args.extras, ext: ext)
-                end
+        if enabled?
+          if namespace
+            require(gem || type)
+            obj = eval(namespace)
+          else
+            as_a(ext).each do |val|
+              next unless (data = @@mime_obj[val])
+
+              obj = data.first
+              break
+            end
+          end
+          if obj
+            ext << type if (ext = as_a(ext)).empty?
+            if !file && target?
+              ext.each do |val|
+                next unless (out = basepath("#{main}.#{val}")).exist?
+
+                file = out
+                break
               end
             end
           end
         end
       rescue LoadError, NameError => e
-        project&.log&.warn e
+        log&.warn e
         self
       else
-        @mime[type] = opts
-        if exist?
-          @command = command
+        (@mime[type] ||= []) << [command || @command, file, opts]
+        if target?
+          @mime[type].freeze
           @mime.freeze
         end
         self
       end
 
-      def also(path, type = nil, name: nil, gem: nil, parse: nil, opts: {})
+      def also(path, type = nil, name: nil, **kwargs)
         return self if @mime.frozen? || !(file = basepath(path)).exist?
 
         ext = mimetype(file)
-        type = type&.to_s || ext
-        unless parse
-          case type
-          when 'json'
-            parse = 'JSON'
-          when 'yaml', 'yml'
-            type = 'yaml'
-            parse = 'YAML'
-          end
-        end
+        type ||= ext
         name ||= file.basename.to_s.chomp(File.extname(file))
-        add(type, gem: gem, parse: parse, ext: ext, opts: opts, command: name, file: file, exist: true)
+        add(type, ext: ext, command: name, file: file, **kwargs)
       end
 
       def style(name, *args)
@@ -141,23 +175,23 @@ module Squared
       end
 
       def enabled?
-        return File.exist?(realpath) if exist?
+        return File.exist?(realpath) if target?
 
         !@required || !!project&.enabled?
       end
 
       def extensions
-        exist? ? [@ext.sub('.', '')] : @mime.keys
+        target? ? [@ext.sub('.', '').downcase] : @mime.keys
       end
 
       def to_s
-        realpath if exist?
+        realpath if target?
 
         @mime.keys.map { |ext| "#{main}.#{ext}" }.join(',')
       end
 
       def inspect
-        "#<#{self.class}: #{name} => #{exist? ? realpath : "#{main} {#{extensions.join(', ')}}"}>"
+        "#<#{self.class}: #{name} => #{target? ? realpath : "#{main} {#{extensions.join(', ')}}"}>"
       end
 
       private
@@ -166,7 +200,11 @@ module Squared
         puts_oe(*args, pipe: pipe)
       end
 
-      def read_keys(reader, type, file, keys, ext: [type])
+      def log
+        project&.log
+      end
+
+      def read_keys(reader, type, file, keys, ext: [type], opts: {})
         if file && (mime = mimetype(file)) && basepath(file).exist?
           raise_error(file, mime, hint: 'invalid') unless ext.include?(mime)
         else
@@ -187,14 +225,15 @@ module Squared
             raise_error(reader.name, "#{File.basename(alt, '.*')}.#{ext.first}", **args)
           end
         end
-        project&.log&.info "#{Viewer}(#{type}) => #{file} {#{keys.join(', ')}}"
+        log&.info "#{Viewer}(#{type}) => #{file} {#{keys.join(', ')}}"
+        return puts File.read(file) if keys.last == '*'
+
         doc = if reader.respond_to?(:load_file)
-                reader.load_file(file, **@mime[type])
+                reader.load_file(file, **opts)
               else
-                reader.parse(File.read(file), **@mime[type])
+                reader.parse(File.read(file), **opts)
               end
-        lines = print_keys(type, doc, keys, file: file)
-        return unless lines
+        return unless (lines = print_keys(type, doc, keys, file: file, opts: opts))
 
         title = Pathname.new(file)
                         .realpath
@@ -213,13 +252,13 @@ module Squared
                                                 { pat: /\A(.+ : (?!undefined))([^"\[{].*)\z/m, styles: theme[:value],
                                                   index: 2 }
                                               ]
-                                            end)
+                                            end, border: theme[:border])
       end
 
-      def print_keys(type, data, keys, file: nil)
+      def print_keys(type, data, keys, file: nil, opts: {})
         out = []
         pad = 0
-        symbolize = @mime[type][:symbolize_names]
+        symbolize = opts[:symbolize_names]
         keys.each do |key|
           begin
             items = key.split('.')
@@ -234,7 +273,7 @@ module Squared
               end
             end
           rescue StandardError
-            project&.log&.warn "#{Viewer}(#{type}) => #{file && "#{file} "}{#{key}: undefined}"
+            log&.warn "#{Viewer}(#{type}) => #{file && "#{file} "}{#{key}: undefined}"
             val = Regexp.escape($!.message)
             key = key.sub(/(#{val})\.|\.(#{val})|(#{val})/) do
               s = "<#{$3 || $2 || $1}>"
@@ -258,17 +297,26 @@ module Squared
       end
 
       def task_name(val)
-        @prefix ? "#{@prefix}:#{val}" : val.to_s
+        if project
+          project.workspace.task_name(val)
+        else
+          @prefix ? "#{@prefix}:#{val}" : val.to_s
+        end
       end
 
-      def format_desc(command, *ext, exist: exist?)
-        return unless Rake::TaskManager.record_task_metadata
+      def task_desc(command, *ext, target: nil)
+        return unless @@task_desc
 
-        val = "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys+]"
-        message(@prefix, *name.split(':'), command, val, empty: true)
+        val = "#{ext.first}[#{target ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys+]"
+        args = *name.split(':').push(command, val)
+        if project
+          project.workspace.task_desc(*args)
+        else
+          desc message(@prefix, *args, empty: true)
+        end
       end
 
-      def exist?
+      def target?
         !@ext.empty? && (!@required || !project.nil?)
       end
 

data/lib/squared/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Squared
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end