grably 0.0.1

data/lib/grably/core/commands.rb

@@ -0,0 +1,23 @@
+require 'fileutils'
+require 'digest/sha1'
+
+require_relative 'commands/digest'
+require_relative 'commands/cp'
+require_relative 'commands/log'
+require_relative 'commands/run'
+require_relative 'commands/serialize'
+
+module Grably # :nodoc:
+  # Make all methods as MODULE methods
+  def self.method_added(m)
+    module_function m
+  end
+
+  def relative_path(base, path)
+    # TODO: Reimplement
+    Dir.chdir(base) do
+      path = File.expand_path(path)
+    end
+    path
+  end
+end

data/lib/grably/core/commands/cp.rb

@@ -0,0 +1,103 @@
+module Grably # :nodoc:
+  # Copy files or products to destination directory
+  # @param products [Array<Product>] list of products to copy
+  # @param dst_dir [String] destination directory to copy products
+  # @param base_dir [String] if provided all products will be copied relative to
+  #   this path inside destination
+  # @param log [Boolean] if provided will log all actions to STDOUT. false by
+  #   default
+  # @return [Array<Product>] list of resulting products.
+  def cp(products, dst_dir, base_dir: nil, log: false)
+    products = Product.expand(products)
+    dst_dir = File.expand_path(dst_dir)
+    dst_dir = File.join(dst_dir, base_dir) if base_dir
+
+    products.map { |product| copy_product(product, dst_dir, log: log) }
+  end
+
+  # Smart copy operates over product lists in the way like it directory
+  # structures. All chaned products will be replaced and missing products
+  # will be removed.
+  # @param products [Array<Product>] list of products to copy. Any expand
+  #   expression will work as expected.
+  # @param dst_dir [String] target directory path.
+  # @param log [Boolean] if set to true log all actions to STDOUT. false by
+  #   default
+  # @return [Array<Product>] list of resulting products
+  def cp_smart(products, dst_dir, log: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # Ensure dst_dir is created
+    FileUtils.mkdir_p(dst_dir) unless File.exist?(dst_dir)
+    # Create Hash structures containing product.dst => product mappings
+    update = ->(acc, elem) { acc.update(elem.dst => elem) }
+    src_products = Product.expand(products).inject({}, &update)
+    dst_products = Product.expand(dst_dir).inject({}, &update)
+
+    # Looking for missing files
+    remove_files = (dst_products.keys - src_products.keys).each do |dst_key|
+      log "Remove #{dst_key} (#{dst_products[dst_key].src}" if log
+    end
+    FileUtils.rm(remove_files.map { |k| dst_products[k].src })
+    rm_empty_dirs(dst_dir)
+    # Update rest
+    src_products.map do |dst, product|
+      dst_product = dst_products[dst]
+      update_smart(product, dst_product, dst_dir, log: log)
+    end
+  end
+
+  # Copy product to dst using FileUtils
+  def cp_sys(src, dst, log: false)
+    src = src.src if src.is_a?(Product)
+    dst = dst.src if dst.is_a?(Product)
+    log "Copy #{File.basename(src)} to #{dst}" if log
+    FileUtils.cp_r(src, dst)
+  end
+
+  private
+
+  def rm_empty_dirs(dir)
+    Dir[File.join(dir, '**/*')]
+      .select { |p| File.directory?(p) }
+      .select { |d| (Dir.entries(d) - %w(. ..)).empty? }
+      .each { |d| Dir.rmdir(d) }
+  end
+
+  def copy_product(product, dst_dir, log: false)
+    copy = product.map do |_src, dst, _meta|
+      File.join(dst_dir, dst)
+    end
+
+    dir = File.dirname(copy.dst)
+    FileUtils.mkdir_p(dir) unless File.exist?(dir)
+    log "Copy #{File.basename(product.src)} to #{copy.src}" if log
+    FileUtils.cp(product.src, copy.src)
+
+    copy
+  end
+
+  def update_smart(src_product, dst_product, dst_dir, log: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/LineLength
+    if dst_product
+      # Check if file changed. If so updating it
+      # TODO: Should we or should not check hashsum
+      if product_changed?(src_product, dst_product)
+        log "Update #{src_product.basename} to #{dst_product.src}" if log
+        FileUtils.cp(src_product.src, dst_product.src)
+      end
+    else
+      dst_product = src_product.map do |_src, dst, _meta|
+        File.join(dst_dir, dst)
+      end
+      dir = File.dirname(dst_product.src)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      log "Copy #{src_product.basename} to #{dst_product.src}" if log
+      FileUtils.cp(src_product.src, dst_product.src)
+    end
+
+    dst_product
+  end
+
+  def product_changed?(p1, p2)
+    # TODO: Should we or should not check hashsums of files?
+    digest(p1) != digest(p2) if File.mtime(p1.src) != File.mtime(p2.src)
+  end
+end

data/lib/grably/core/commands/digest.rb

@@ -0,0 +1,12 @@
+require 'digest/sha2'
+
+module Grably # :nodoc:
+  def digest(src, buff_len: 4096)
+    src = src.src if src.is_a?(Product)
+    sha = ::Digest::SHA2.new
+    File.open(src, 'rb') do |f|
+      sha << f.read(buff_len) until f.eof?
+    end
+    sha.hexdigest
+  end
+end

data/lib/grably/core/commands/log.rb

@@ -0,0 +1,19 @@
+module Grably # :nodoc:
+  def log(msg)
+    puts msg
+    # flush stdout - we need that to have submodules displaying OK
+    $stdout.flush
+  end
+
+  def err(msg)
+    puts 'error: '.red.bright + msg
+  end
+
+  def warn(msg)
+    puts 'warning: '.cyan.bright + msg.to_s.cyan
+  end
+
+  def trace(msg)
+    puts msg if ENV['TRACE']
+  end
+end

data/lib/grably/core/commands/run.rb

@@ -0,0 +1,85 @@
+# Ruby array extensions
+class Array
+  # Run array content as shell command
+  def run(&block)
+    Grably.run(self, &block)
+  end
+
+  # Run array content as shell command and handle exception automaticly
+  def run_safe
+    Grably.run_safe(self)
+  end
+
+  # Run array content as shell command and print it output to STDOUT
+  def run_log
+    Grably.run_log(self)
+  end
+end
+
+module Grably # :nodoc:
+  # TODO: Rewimplement
+  # rubocop:disable all
+  class << self
+    def run_log(cmd)
+      run(cmd) { |l| log "  #{l}" }
+    end
+
+    def run(cmd, &block)
+      env = {}
+
+      cmd = [cmd] if cmd.is_a?(Hash)
+      cmd = cmd.split(' ') unless cmd.is_a?(Array)
+      cmd = cmd.flatten.compact
+
+      cmd.map! do |c|
+        if c.is_a?(String) && c.empty?
+          c = nil
+        elsif c.is_a?(Hash)
+          env.merge!(c)
+          c = nil
+        end
+        c = c.to_s unless c.nil?
+        c
+      end
+
+      cmd = cmd.flatten.compact
+
+      # Not all windows apps "slash tolerant"
+      if windows?
+        cmd[0] = cmd[0].tr('/', '\\') unless cmd.empty?
+      end
+
+      pwd = nil
+      if env['__WORKING_DIR']
+        pwd = Dir.pwd
+        Dir.chdir(env.delete('__WORKING_DIR'))
+      end
+
+      r = []
+      IO.popen([env, cmd, { err: %i(child out) }].flatten) do |o|
+        o.sync = true
+        o.each do |l|
+          r << l
+          yield(l) unless block.nil?
+        end
+      end
+
+      Dir.chdir(pwd) if pwd
+
+      raise 'error: '.red.bright + cmd.red + "\nfail log: #{r}".green unless $?.exitstatus.zero?
+
+      r.join
+    end
+
+    def run_safe(cmd)
+      begin
+        run(cmd)
+      rescue
+        return false
+      end
+
+      true
+    end
+    # rubocop:enable all
+  end
+end

data/lib/grably/core/commands/serialize.rb

@@ -0,0 +1,16 @@
+module Grably # :nodoc:
+  def load_obj(filename)
+    return nil unless File.exist? filename
+    File.open(filename) do |f|
+      Marshal.load(f) # rubocop:disable Security/MarshalLoad
+    end
+  rescue StandardError => x
+    raise(x, "Can't deserialize #{filename}")
+  end
+
+  def save_obj(filename, obj)
+    dir = File.dirname(filename)
+    FileUtils.mkdir(dir) unless File.exist?(dir)
+    File.open(filename, 'w') { |f| Marshal.dump(obj, f) }
+  end
+end

data/lib/grably/core/configuration.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+require 'ostruct'
+require 'jac'
+
+require_relative 'configuration/pretty_print'
+
+module Grably
+  module Core
+    # Grably configuration module.
+    # We use jac for configuration
+    # @see https://github.com/vizor-games/jac
+    module Configuration
+      # Default configuration file names
+      CONFIGURATION_FILES = %w(grably.yml grably.user.yml grably.override.yml).freeze
+
+      class << self
+        # Generates configuration object for given profile
+        # and list of streams with YAML document
+        # @param profile [Array] list of profile names to merge
+        # @param streams [Array] list of YAML documents and their
+        # names to read
+        # @return [OpenStruct] instance which contains all resolved profile fields
+        def read(profile, *streams)
+          Jac::Configuration.read(profile, *streams)
+        end
+
+        # Read configuration from configuration files.
+        # @praram [String or Array] profile which should be loaded
+        # @param [String] dir base directory path for provided files may be nil
+        # @return [OpenStruct] resolved profile values
+        def load(profile, dir: nil)
+          obj = Jac::Configuration.load(profile, files: CONFIGURATION_FILES, dir: dir)
+          obj.extend(self)
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/grably/core/configuration/pretty_print.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+require_relative '../colors'
+
+module Grably
+  module Core
+    module Configuration # :nodoc:
+      # rubocop:disable all
+      class ConfigurationVisitor < Psych::Visitors::YAMLTree
+        def visit_Symbol(o)
+          visit_String(o.to_s)
+        end
+      end
+      # rubocop:enable all
+
+      def pretty_print
+        visitor = ConfigurationVisitor.create
+        visitor << to_h
+        visitor.tree.yaml STDOUT, {}
+      end
+    end
+  end
+end

data/lib/grably/core/digest.rb

@@ -0,0 +1,93 @@
+require 'digest'
+require 'set'
+
+require_relative 'product'
+
+module Grably
+  # Set of utilities to digest products and stat product set changes
+  module Digest
+    # Describes product state. If two digests for same file differs assume file changed
+    class ProductDigest
+      attr_reader :mtime, :size, :md5, :product
+
+      def initialize(product, mtime:, size:, md5:)
+        @product = product
+        @mtime = mtime
+        @size = size
+        @md5 = md5
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        [
+          product == other.product,
+          mtime == other.mtime,
+          size == other.size,
+          md5 == other.md5
+        ].all?
+      end
+
+      def hash
+        md5.to_i
+      end
+
+      def self.[](*products)
+        products.map { |p| of_product(p) }
+      end
+
+      def self.of_product(product)
+        product = Product.new(product) if product.is_a?(String)
+        raise 'Expected string or Product got ' + product.inspect unless product.is_a? Product
+        src = product.src
+        raise 'File does not exist' unless File.exist? src
+        ProductDigest.new(
+          product,
+          mtime: File.mtime(src),
+          size: File.size(src),
+          md5: ::Digest::MD5.hexdigest(IO.binread(src))
+        )
+      end
+    end
+
+    class << self
+      def digest(*products)
+        products.map { |product| ProductDigest.of_product(product) }
+      end
+
+      # Given two lists of product digests
+      # find missing, changed, and added products
+      # @return [deleted, added, updated]
+      def diff_digests(old_products, new_products)
+        # create maps of product sets
+        old_map, new_map = [old_products, new_products].map do |products|
+          return [] unless products
+          Hash[*products.flat_map { |d| [d.product, d] }]
+        end
+
+        build_diff(new_map, old_map)
+      end
+
+      def build_diff(new_map, old_map)
+        old_keys = old_map.keys.to_set
+        new_keys = new_map.keys.to_set
+
+        missing = old_keys - new_keys
+        added = new_keys - old_keys
+
+        updated = (old_keys & new_keys).reject do |product|
+          old_map[product] == new_map[product]
+        end
+
+        [missing, added, updated]
+      end
+
+      # Tells if two product digest lists are differ
+      def differ?(old_products, new_products)
+        !diff_digests(old_products, new_products).flatten.empty?
+      end
+    end
+  end
+end

data/lib/grably/core/dsl.rb

@@ -0,0 +1,15 @@
+module Grably
+  # Contains custom Grably DSL definitions.
+  module DSL
+    def grab(module_call, as:, &block)
+      executor = Grably.server.schedule(module_call)
+
+      last_desc = Rake.application.last_description
+      desc module_call.pretty_print unless last_desc
+      task(as) do |t|
+        products = executor.call(t.task_dir)
+        block ? yield(t, products) : (t << products)
+      end
+    end
+  end
+end

data/lib/grably/core/essentials.rb

@@ -0,0 +1,49 @@
+module Grably # :nodoc:
+  # Short OS family name
+  # :win - Windows
+  # :linux - Linux
+  # :mac - OS X
+  PLATFORM = case RUBY_PLATFORM
+             when /mingw/, /cygwin/
+               :windows
+             when /mac/, /darwin/
+               :mac
+             else
+               :linux
+             end
+  # Number of CPU cores
+  CORES_NUMER = case PLATFORM
+                when :windows
+                  # this works for windows 2000 or greater
+                  require 'win32ole'
+                  wmi = WIN32OLE.connect('winmgmts://')
+                  query = 'select * from Win32_ComputerSystem'
+                  wmi.ExecQuery(query).each do |system|
+                    begin
+                      processors = system.NumberOfLogicalProcessors
+                    rescue StandardError => x
+                      puts 'Warn: ' + x.message
+                      processors = 1
+                    end
+                    return [system.NumberOfProcessors, processors].max
+                  end
+                when :mac
+                  `sysctl -n hw.logicalcpu`.to_i
+                when :linux
+                  `cat /proc/cpuinfo | grep processor | wc -l`.to_i
+                else
+                  raise "can't determine 'number_of_processors' for '#{RUBY_PLATFORM}'"
+                end
+
+  class << self
+    %w(windows mac linux).each do |platform|
+      # rubocop:disable Security/Eval
+      eval("def #{platform}?; #{PLATFORM == platform} end")
+      # rubocop:enable Security/Eval
+    end
+
+    def cores_number
+      CORES_NUMBER
+    end
+  end
+end