grably 0.0.1

data/lib/grably/core/module.rb

@@ -0,0 +1,64 @@
+require 'rake/application'
+module Grably
+  # Methods for working with submodules
+  module Module
+    # List of file names we can load as submodule entry
+    DEFAULT_FILES = Rake::Application::DEFAULT_RAKEFILES
+
+    # Reference to external module task call
+    class ModuleCall
+      attr_reader :path, :profile, :task
+      # Initializes module reference with load path and profile
+      # @param [String] path absolute path to referencing module
+      def initialize(path, task, profile = c.profile)
+        @path = path
+        @task = task
+        @profile = profile
+      end
+
+      # Updates profile settings in module ref
+      # @param [*String] profile profile names
+      def with_profile(*profile)
+        @profile = profile
+        self
+      end
+
+      def pretty_print
+        profiles = [*profile].flatten.join(', ')
+        "Call Grably[#{path} / #{profiles}] #{task.to_s.white.bright}"
+      end
+    end
+
+    class << self
+      # Get submodule object
+      # @param [String] path relative path to sumbodule
+      # @return [Grably::Module::ModuleCall] addresed submodule
+      def reference(path, task)
+        base_path = File.expand_path(File.join(Dir.pwd, path))
+        raise "#{path} does not exist" unless File.exist?(path)
+        path = if File.directory?(base_path)
+                 ensure_module_dir(base_path)
+               else
+                 ensure_filename(base_path)
+               end
+        ModuleCall.new(path, task)
+      end
+
+      # Ensures that provided path points to one of allowed to load files
+      def ensure_filename(path)
+        basename = File.basename(path)
+        return path if DEFAULT_FILES.include?(basename)
+
+        exp = DEFAULT_FILES.join(', ')
+        raise "Wrong file name #{basename} expected one of #{exp}"
+      end
+
+      def ensure_module_dir(path)
+        base_path = Dir["#{path}/*"]
+                    .find { |f| DEFAULT_FILES.include?(File.basename(f)) }
+        raise "Can't find any file to load in #{path}" unless base_path
+        base_path
+      end
+    end
+  end
+end

data/lib/grably/core/product.rb

@@ -0,0 +1,301 @@
+require 'powerpack/string/format' # Adds format method
+require 'powerpack/string/remove_prefix'
+require_relative 'task'
+
+module Grably
+  module Core
+    class Product
+      # Class stub for future reference.
+      # Main implementation goes below
+    end
+
+    # Set of predefined product filters, used by ProductExpand
+    module ProductFilter
+      # Generates lambda filter out of `String` with
+      # glob pattern description
+      def generate_glob_filter(glob)
+        # Negative glob starts with '!'
+        negative = glob.start_with?('!')
+        # Strip leading '!' then
+        glob.remove_prefix!('!') if negative
+        lambda do |path|
+          # TODO: I'm pretty sure that someone would like to have set_no_extglob, set_no_dotmatch, set_no_pathname
+          # TODO: as global methods for ProductFilter module
+          matches = File.fnmatch(glob, path, File::FNM_EXTGLOB | File::FNM_DOTMATCH | File::FNM_PATHNAME)
+          # inverse match if glob is negative
+          matches = !matches if negative
+          matches
+        end
+      end
+
+      # Matches filter string
+      FILTER_STRING_REGEXP = /^((((?<new_base>.+?)?:)?((?<old_base>.+?)?:))?)(?<glob>.+)$/
+      # FILTER_STRING_REGEXP groups in fixed order.
+      FILTER_STRING_GROUPS = %i(new_base old_base glob).freeze
+
+      def generate_string_filter(filter_string)
+        new_base, old_base, glob = parse_string_filter(filter_string)
+        glob_filter = generate_glob_filter(glob)
+        lambda do |products, _expand|
+          filtered = filter_products(products, new_base, old_base) { |_src, dst, _meta| glob_filter.call(dst) }
+          filtered.map { |src, dst, meta| Product.new(src, dst, meta) }
+        end
+      end
+
+      def parse_string_filter(filter_string)
+        # Here we need generate lambda for string filter
+        parsed_filter = FILTER_STRING_REGEXP.match(filter_string) do |m|
+          FILTER_STRING_GROUPS.map { |g| m[g] }
+        end
+        parsed_filter || raise('Filter \'%s\' doesn\'t match format'.format(filter_string))
+      end
+
+      def filter_products(products, new_base, old_base, &dst_filter)
+        products
+          .map { |p| [p.src, p.dst, p.meta] }
+          .select { |_, dst, _| !old_base || dst.start_with?(old_base) }
+          .map { |src, dst, meta| [src, dst.gsub(%r{^#{old_base.to_s}[/\\]}, ''), meta] }
+          .select(&dst_filter)
+          .map { |src, dst, meta| [src, new_base.nil? ? dst : File.join(new_base, dst), meta] }
+      end
+    end
+
+    # Product expansion rules.
+    # Expand is mapping from anything(almost) to list of products
+    #
+    # We have following expansion rules:
+    #
+    # * Symbol can represent following entities:
+    #
+    #   * `:task_deps` - all all backets from all task prerequisites
+    #   * `:last_job` - result of last executed job
+    #   * any other symbol - backet of task with that name
+    #
+    # * Hash describes mapping from product expandable expression to filter in form of `{ expr => filter }`.
+    #   Filter can be either string or lambda (proc).
+    #   * If filter is a String it can be:
+    #     * glob pattern (`gN`)
+    #     * negative glob pattern, e.g. `!` is prepended (`!gN`)
+    #     * filter with substitution (can be in two forms):
+    #     * `base:glob` - select every file starting with `base`, strip `base`
+    #       from beginning, apply glob to the rest of path
+    #     * `new_base:old_base:glob` - select every file starting with base,
+    #       strip `old_base`, apply glob to the rest of path, add `new_base`
+    #     Every operation is performed over Product `dst`, not `src`.
+    #    `glob` means any glob (either simple glob or negative glob)
+    #
+    #   * If filter is `Proc`:
+    #
+    #     * this proc must have arity of 2
+    #     * first argument is expanded expression `expr`
+    #     * second argument is contexted expand function (which means it have proper task argument)
+    #
+    # * `Array` expansion is expanding each element
+    #
+    # * `String` expands as glob pattern
+    #   If string is path to file, then it expands into single element array of products.
+    #   Else (i.e. string is directory) it expands into array of products representing
+    #   directory content.
+    #
+    # * {Grably::Core::Task} expands to its backet.
+    #   Behaving strictly we can only get task backet of
+    #   self, i.e. target_task == context_task, or if target_task is
+    #   context_task prerequisite (direct or indirect).
+    #
+    # * Product expands to self
+    module ProductExpand
+      class << self
+        include ProductFilter
+
+        def expand(srcs, task = nil)
+          # Wrap o in Array to simplify processing flow
+          srcs = [srcs] unless srcs.is_a? Array
+          # First typed expand will be array expand. So we will get array as
+          # result
+          typed_expand(srcs, task)
+        end
+
+        def expand_symbol(symbol, task)
+          case symbol
+          when :task_deps
+            typed_expand(task.prerequisites.map(&:to_sym), task)
+          else
+            task_ref = Task[symbol]
+            typed_expand(task_ref, task)
+          end
+        end
+
+        def expand_hash(hash, task)
+          hash.flat_map do |expr, filter|
+            # If got string generate lambda representing filter operation
+            filter = generate_string_filter(filter) if filter.is_a? String
+            raise 'Filter is not a proc %s'.format(filter) unless filter.is_a?(Proc)
+            filter.call(typed_expand(expr, task), ->(o) { expand(o, task) })
+          end
+        end
+
+        def expand_array(elements, task)
+          elements.flat_map { |e| typed_expand(e, task) }
+        end
+
+        def expand_string(expr, _task)
+          unless File.exist?(expr)
+            warn "'#{expr}' does not exist. Can't expand path"
+            return []
+          end
+          # Will expand recursively over directory content.
+          if File.directory?(expr)
+            expand_dir(expr)
+          else
+            Product.new(expr)
+          end
+        end
+
+        def expand_proc(proc, task)
+          proc.call(->(o) { expand(o, task) })
+        end
+
+        def expand_task(target_task, context_task)
+          # Behaving strictly we can only get task backet of
+          # self, i.e. target_task == context_task, or if target_task is
+          # context_task prerequisite (direct or indirect).
+          unless check_dependencies(target_task, context_task)
+            raise(ArgumentError,
+                  'Target task [%s] is not in context task [%s] prerequisites'
+                      .format(target_task.name, context_task.name))
+          end
+          target_task.bucket
+        end
+
+        def expand_product(product, _)
+          product
+        end
+
+        # We define method table for expand rules.
+        # Key is object class, value is method.
+        #
+        # Initially we just define set of Class to Symbol mappings. Then calling
+        # ProductExpand.singleton_method on each method name.
+        # As bonus following this technique we will get NameError
+        # immediately after module load.
+        METHOD_TABLE =
+          Hash[*{
+            Symbol => :expand_symbol,
+            Hash => :expand_hash,
+            Array => :expand_array,
+            String => :expand_string,
+            Proc => :expand_proc,
+            Grably::Core::Task => :expand_task,
+            Product => :expand_product
+          }
+          .flat_map { |k, v| [k, ProductExpand.singleton_method(v)] }]
+          .freeze
+
+        def typed_expand(element, task)
+          # Fetching expand rule for element type
+          method_refs = METHOD_TABLE.select { |c, _| element.is_a?(c) }
+          raise 'Multiple expands found for %s. Expands %s'.format(element, method_refs.keys) if method_refs.size > 1
+          method_ref = method_refs.values.first
+          unless method_ref
+            err = 'No expand for type: %s. Element is \'%s\''
+            raise err.format(element.class, element)
+          end
+          # Every expand_%something% method follows same contract, so we just
+          # passing standard set of arguments
+          method_ref.call(element, task)
+        end
+
+        ## Utility methods
+
+        # Ensure that target task is among context_task dependencies
+        def check_dependencies(target_task, context_task)
+          return true if target_task == context_task
+          context_task.all_prerequisite_tasks.include?(target_task)
+        end
+
+        private
+
+        def expand_dir(expr)
+          glob = File.join(expr, '**/*')
+          Dir[glob]
+            .select { |entry| File.file?(entry) }
+            .map { |file| Product.new(file, file.sub(expr + File::SEPARATOR, '')) }
+        end
+      end
+    end
+
+    # Product is core, minimal entity in build process.
+    # It describes real file with virtual destination.
+    # Product instances should be immutable.
+    class Product
+      attr_reader :src, :dst, :meta
+
+      def initialize(src, dst = nil, meta = {})
+        raise 'src should be a string' unless src.is_a?(String)
+        raise 'dst should be a string' unless dst.is_a?(String) || dst.nil?
+        @src = File.expand_path(src)
+        @dst = dst || File.basename(src)
+        @meta = meta.freeze # Ensure meta is immutable
+      end
+
+      def [](*keys)
+        return @meta[keys.first] if keys.size == 1
+
+        # Iterate over keys to preserve order so we can unpack result
+        # like:
+        # foo, bar = product[:foo, :bar]
+        keys.map { |k| @meta[k] }
+      end
+
+      def update(values)
+        # Provide immutable update
+        Product.new(@src, @dst, @meta.merge(values))
+      end
+
+      def exist?
+        File.exist?(@src)
+      end
+
+      def inspect
+        'Product[src=\'%s\', dst=\'%s\', meta=%s]'.format(src, dst, meta)
+      end
+
+      def map
+        src, dst, meta = yield(@src, @dst, @meta)
+        Product.new(src || @src, dst || @dst, meta || @meta)
+      end
+
+      def to_s
+        inspect
+      end
+
+      def ==(other)
+        # Everything which not a Product, can't be equal to Product
+        return false unless other.is_a? Product
+
+        # Should we include meta in comparison?
+        @src.eql?(other.src) && @dst.eql?(other.dst)
+      end
+
+      def hash
+        @src.hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def basename(*args)
+        File.basename(@dst, *args)
+      end
+
+      # Including helper classes
+      # Utility logic extracted from Product class to keep it clean and concise
+      class << self
+        def expand(expr, task = nil)
+          Grably::Core::ProductExpand.expand(expr, task)
+        end
+      end
+    end
+  end
+end

data/lib/grably/core/task.rb

@@ -0,0 +1,30 @@
+require 'rake/task'
+
+require_relative 'task/bucket'
+require_relative 'task/jobs'
+require_relative 'task/expand'
+require_relative 'task/enchancer'
+
+module Grably
+  # All working files are stored under .grably directory.
+  WORKING_DIR = '.grably'.freeze
+
+  module Core
+    # We use Grably::Core::Task as alias to Rake::Task
+    Task = Rake::Task
+
+    # Here we will put extension methods for task
+    module TaskExtensions
+      include Grably::Core::TaskExtensions::Bucket
+      include Grably::Core::TaskExtensions::Jobs
+      include Grably::Core::TaskExtensions::Expand
+    end
+  end
+end
+
+module Rake
+  class Task # :nodoc:
+    include Grably::Core::TaskExtensions
+    include Grably::Core::TaskEnchancer
+  end
+end

data/lib/grably/core/task/bucket.rb

@@ -0,0 +1,29 @@
+module Grably
+  module Core
+    module TaskExtensions
+      # # Bucket
+      # Bucket keeps result of task execution
+      module Bucket
+        # Updates bucket with result of argument expand
+        # @see [Grably::Core::ProductExpand]
+        # @param product_expr
+        # @return [Task]
+        def <<(product_expr)
+          expand = Product.expand(product_expr, self)
+          ensure_bucket
+          @bucket += expand
+
+          self # Allow chaining calls like
+        end
+
+        def bucket
+          ensure_bucket
+        end
+
+        def ensure_bucket
+          @bucket ||= []
+        end
+      end
+    end
+  end
+end

data/lib/grably/core/task/enchancer.rb

@@ -0,0 +1,50 @@
+module Grably
+  module Core
+    # Wraps execute method, to print fancy info
+    # about task and its execution.
+    module TaskEnchancer
+      class << self
+        def included(other_class)
+          other_class.class_eval do
+            alias_method :old_execute, :execute
+
+            def execute(*args)
+              log_execute
+              FileUtils.mkdir_p(task_dir)
+              old_execute(*args)
+              export(to_s, Grably.export_path) if Grably.export_tasks.include?(to_s)
+            end
+          end
+        end
+      end
+
+      def export(name, export_path)
+        puts "Exporting task #{name}"
+        products = bucket
+        # Evacuating files. When task is finished other task execution
+        # may begin and all files that should be exported will be
+        # spoiled.
+
+        # Replace all ':' with '_'. When task name conatains ':' it
+        # means that task declared inside namespace. On Windows we can't
+        # create directory with ':' in name
+        dir_name = name.tr(':', '_')
+        dst = File.join(File.dirname(export_path), dir_name)
+        Grably.exports << cp_smart(products, dst)
+      end
+
+      def task_dir
+        File.join(WORKING_DIR, c.profile.join('-'), name)
+      end
+
+      def log_execute
+        print "* #{self}".blue.bright
+        if Grably.export?
+          puts " (#{Dir.pwd}, #{c.profile.join('/').yellow})".white.bright
+        else
+          puts
+        end
+      end
+    end
+  end
+end