squared 0.0.10 → 0.0.12

data/lib/squared/common/utils.rb

@@ -1,21 +1,48 @@
 # frozen_string_literal: true
 
+require 'pathname'
+require 'rake'
+
 module Squared
   module Common
     module Utils
       module_function
 
-      def env_value(key, suffix: nil)
-        if suffix
-          ret = ENV["#{key}_#{suffix}"]
-          return ret unless ret.nil?
+      def task_invoke(*cmd, args: [], exception: true, warning: true)
+        cmd.each { |name| ::Rake::Task[name].invoke(*args) }
+      rescue StandardError => e
+        raise if exception
+
+        warn e if warning
+      end
+
+      def task_join(*val)
+        case val.size
+        when 1
+          val[0].to_s
+        when 2
+          "#{val[0]}:#{val[1]}"
+        else
+          val.join(':')
         end
-        ENV.fetch(key, '')
       end
 
-      def env_bool(key, default = false, suffix: nil)
-        return default if key.nil?
+      def task_invoked?(name)
+        ::Rake::Task.tasks.any? { |obj| obj.already_invoked && obj.name == name }
+      end
+
+      def env(key, default = nil, suffix: @envname, equals: nil, ignore: nil)
+        ret = env_value(key, suffix: suffix)
+        return ret == equals.to_s unless equals.nil?
+
+        ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
+      end
 
+      def env_value(key, default = '', suffix: nil)
+        suffix && (ret = ENV["#{key}_#{suffix}"]) ? ret : ENV.fetch(key, default)
+      end
+
+      def env_bool(key, default = false, suffix: nil)
         if key.is_a?(::String)
           case env_value(key, suffix: suffix)
           when ''
@@ -26,21 +53,29 @@ module Squared
             true
           end
         else
-          key
+          key.nil? ? default : key
         end
       end
 
-      def env_pipe(key, default = 1, suffix: nil)
-        if key.is_a?(::String)
+      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
+          rescue StandardError => e
+            default = 1
+            warn e
+          end
+        end
+        case key
+        when ::String
           case (ret = env_value(key, suffix: suffix))
           when '0', '1', '2'
-            ret.to_i
-          else
-            default
+            return ret.to_i
           end
-        else
-          key.is_a?(::Numeric) && key >= 0 && key <= 2 ? key : default
+        when ::Numeric
+          return key if key >= 0 && key <= 2
         end
+        default
       end
 
       def env_match(key, default = nil, suffix: nil, options: 0, timeout: nil)
@@ -52,7 +87,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/common.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'pathname'
-require 'rake'
-
 require_relative 'common/base'
 require_relative 'common/class'
 require_relative 'common/format'
+require_relative 'common/prompt'
 require_relative 'common/shell'
 require_relative 'common/system'
-require_relative 'common/task'
 require_relative 'common/utils'

data/lib/squared/config.rb

@@ -7,30 +7,26 @@ require_relative 'common'
 module Squared
   module Config
     class Viewer
-      include Common
-      include Format
+      include Common::Format
       include Utils
       include ::Rake::DSL
 
-      class << self
-        def to_s
-          super.to_s.match(/[^:]+$/)[0]
-        end
+      def self.to_s
+        super.match(/[^:]+$/)[0]
       end
 
       attr_reader :main, :name, :project, :theme
       attr_accessor :pipe
 
-      def initialize(main, name = nil,
-                     project: nil, prefix: nil, dump: nil, opts: {}, auto: true,
-                     common: Common::KEY[:COMMON], pipe: Common::KEY[:PIPE], **)
+      def initialize(main, name = nil, project: nil, prefix: nil, dump: nil, opts: {}, auto: true,
+                     common: ARG[:COMMON], pipe: ARG[:PIPE], **)
         if project
-          main = @project.base_path(main).to_s if (@project = __get__(:project)[project.to_sym])
+          main = @project.basepath(main).to_s if (@project = __get__(:project)[project.to_s])
           @required = true
         end
         @name = name&.to_s || @project&.name
         @prefix = prefix
-        @ext = File.extname(main)
+        @ext = File.extname(main).downcase
         @dump = dump
         @mime = {}
         @theme = common ? __get__(:theme)[:viewer] : {}
@@ -63,10 +59,9 @@ module Squared
       def build
         return unless enabled?
 
-        params = ->(args) { exist? ? [realpath, [args.keys] + args.extras] : [args.keys, args.extras] }
-
         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')
@@ -84,7 +79,6 @@ module Squared
             end
           end
         end
-
         yield self if block_given?
       end
 
@@ -96,11 +90,11 @@ module Squared
           require(gem || type)
           obj = eval(parse)
           ext << type if (ext = as_a(ext)).empty?
-          file = realpath if file.nil? && exist?
+          file = realpath if !file && exist?
 
           namespace task_name(name) do
-            desc format_desc(command, *ext, exist: exist)
             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)
@@ -124,7 +118,7 @@ module Squared
       end
 
       def also(path, type = nil, name: nil, gem: nil, parse: nil, opts: {})
-        return self if @mime.frozen? || !(file = base_path(path)).exist?
+        return self if @mime.frozen? || !(file = basepath(path)).exist?
 
         ext = mime_type(file)
         type = type&.to_s || ext
@@ -142,7 +136,7 @@ module Squared
       end
 
       def style(name, *args)
-        apply_style(theme, name, *args)
+        apply_style(theme, name, args)
         self
       end
 
@@ -163,25 +157,35 @@ module Squared
       def enabled?
         return File.exist?(realpath) if exist?
 
-        !@required || (!project.nil? && project.enabled?)
+        !@required || !!project&.enabled?
       end
 
       private
 
+      def puts(*args)
+        puts_oe(*args, pipe: pipe)
+      end
+
       def read_keys(reader, type, file, keys, ext: [type])
-        if (mime = mime_type(file)) && base_path(file).exist?
+        if file && (mime = mime_type(file)) && basepath(file).exist?
           raise_error(file, mime, hint: 'invalid') unless ext.include?(mime)
         else
           if ext.include?(mime)
             alt = file
             file = nil
             ext[0] = mime
-          else
+          elsif file
             keys.unshift(file)
-            alt = base_path("#{main}.{#{ext.join(',')}}")
+            alt = basepath("#{main}.{#{ext.join(',')}}")
             file = Dir[alt].first
+          else
+            alt = main
+            args = { hint: 'no keys' }
+          end
+          unless file
+            args ||= { hint: 'not found', kind: LoadError }
+            raise_error(reader.name, "#{File.basename(alt, '.*')}.#{ext.first}", **args)
           end
-          raise_error(reader.name, "#{File.basename(alt, '.*')}.#{ext.first}", hint: 'not found') unless file
         end
         project&.log&.info "#{Viewer}(#{type}) => #{file} {#{keys.join(', ')}}"
         doc = if reader.respond_to?(:load_file)
@@ -196,19 +200,19 @@ module Squared
                         .realpath
                         .to_s
                         .sub(Regexp.new("^#{Regexp.escape(File.join(Dir.pwd, ''))}"), '')
-        sub = unless stdin?
-                [
-                  { pat: /^((?:[^:]|(?<! ):(?! ))+)$/, styles: theme[:banner] },
-                  { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: theme[:undefined], index: 2 },
-                  { pat: /^(.+)( : (?!undefined).+)$/m, styles: theme[:key] },
-                  { pat: /^(.+ : )(-?[\d.]+)(\s*)$/m, styles: theme[:number], index: 2 },
-                  { pat: /^(.+ : ")(.+)("\s*)$/m, styles: theme[:string], index: 2 },
-                  { pat: /^(.+ : \{)(.+)(\}\s*)$/m, styles: theme[:hash], index: 2 },
-                  { pat: /^(.+ : \[)(.+)(\]\s*)$/m, styles: theme[:array], index: 2 },
-                  { pat: /^(.+ : (?!undefined))([^"\[{].*)$/m, styles: theme[:value], index: 2 }
-                ]
-              end
-        emphasize(lines, title: title, sub: sub, pipe: pipe == 2 ? $stderr : nil)
+        emphasize(lines, title: title, sub: unless stdin?
+                                              [
+                                                { pat: /^((?:[^:]|(?<! ):(?! ))+)$/, styles: theme[:banner] },
+                                                { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: theme[:undefined], index: 2 },
+                                                { pat: /^(.+)( : (?!undefined).+)$/m, styles: theme[:key] },
+                                                { pat: /^(.+ : )(-?[\d.]+)(\s*)$/m, styles: theme[:number], index: 2 },
+                                                { pat: /^(.+ : ")(.+)("\s*)$/m, styles: theme[:string], index: 2 },
+                                                { pat: /^(.+ : \{)(.+)(\}\s*)$/m, styles: theme[:hash], index: 2 },
+                                                { pat: /^(.+ : \[)(.+)(\]\s*)$/m, styles: theme[:array], index: 2 },
+                                                { pat: /^(.+ : (?!undefined))([^"\[{].*)$/m, styles: theme[:value],
+                                                  index: 2 }
+                                              ]
+                                            end)
       end
 
       def print_keys(type, data, keys, file: nil)
@@ -252,8 +256,8 @@ module Squared
         end
       end
 
-      def base_path(file)
-        project ? project.base_path(file) : Pathname.new(file).realdirpath
+      def basepath(file)
+        project ? project.basepath(file) : Pathname.new(file).realdirpath
       end
 
       def task_name(val)
@@ -266,19 +270,20 @@ module Squared
           'yaml'
         when 'js'
           'json'
+        when ''
+          nil
         else
-          ret.empty? ? nil : ret
+          ret
         end
       end
 
       def format_desc(command, *ext, exist: exist?)
-        message(@prefix || '', *name.split(':'), command,
-                "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys*]")
+        val = "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys+]"
+        message(@prefix, *name.split(':'), command, val, empty: true)
       end
 
       def realpath
-        file = main + @ext
-        Pathname.new(file).realdirpath.to_s rescue file
+        basepath(file = main + @ext).to_s rescue file
       end
 
       def exist?

data/lib/squared/version.rb

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