eco-rake 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06f88149753ab7424d569e1875bb0d0d5a914c3566b07a254fdcc6e71b101eb0
+  data.tar.gz: 06cac6560a9d130b858de701ac45a7015ffff6382d2a9418ba7e2f9fcbf37fbd
+SHA512:
+  metadata.gz: cec87e0b5884b049d4a5ae70b92454050c9177b32bde8055a93240dd7138783be6ec65b9b80c2ff8e830c8832958c4714031bf54db03c336e3a5cdd599ef1a24
+  data.tar.gz: affe3d449e395b6c6b143f71cb2821a2bd08b30e8609cc7df27575ab65faf2d8feead5297e056ad96953c4379b5e16e1be18be1ae5df133073493b50a128225b

data/.gitignore

@@ -0,0 +1,28 @@
+# env files
+.env*
+
+# core development-only executables
+/bin/raked*
+
+# it's a gem, ignore the lockfile
+Gemfile.lock
+
+# build artifacts
+*.gem
+/.bundle/
+/vendor/bundle
+/spec/reports/
+/tmp/
+/pkg/
+
+# docs
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+
+# rspec failure tracking
+.rspec_status
+scratch.rb
+
+/.byebug_history

data/.gitlab-ci.yml

@@ -0,0 +1,13 @@
+# You can override the included template(s) by including variable overrides
+# SAST customization: https://docs.gitlab.com/ee/user/application_security/sast/#customizing-the-sast-settings
+# Secret Detection customization: https://docs.gitlab.com/ee/user/application_security/secret_detection/#customizing-settings
+# Dependency Scanning customization: https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#customizing-the-dependency-scanning-settings
+# Container Scanning customization: https://docs.gitlab.com/ee/user/application_security/container_scanning/#customizing-the-container-scanning-settings
+# Note that environment variables can be set in several places
+# See https://docs.gitlab.com/ee/ci/variables/#cicd-variable-precedence
+stages:
+- test
+sast:
+  stage: test
+include:
+- template: Security/SAST.gitlab-ci.yml

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,90 @@
+AllCops:
+  TargetRubyVersion: 2.7.2
+  Exclude:
+    - 'config/routes.rb'
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+Naming/FileName:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+Metrics/BlockLength:
+  ExcludedMethods: [context, describe]
+  Max: 50
+Metrics/MethodLength:
+  Max: 50
+Metrics/ClassLength:
+  Max: 200
+Metrics/ModuleLength:
+  Max: 200
+Metrics/AbcSize:
+  Max: 50
+  Exclude:
+    - 'lib/eco-rake/base/method_helpers.rb'
+Metrics/CyclomaticComplexity:
+  Max: 10
+  Exclude:
+    - 'lib/eco-rake/base/method_helpers.rb'
+Metrics/PerceivedComplexity:
+  Max: 10
+  Exclude:
+    - 'lib/eco-rake/base/method_helpers.rb'
+
+ParameterLists:
+  Max: 5
+  CountKeywordArgs: false
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+Style/StringLiterals:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/CommentedKeyword:
+  Enabled: false
+Style/MultilineBlockChain:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+Style/AndOr:
+  Enabled: false
+Style/SlicingWithRange:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/OptionalBooleanParameter:
+  Enabled: false
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_fixed_indentation
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+Layout/AccessModifierIndentation:
+  EnforcedStyle: indent
+Layout/DotPosition:
+  EnforcedStyle: trailing
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: false
+Layout/SpaceInsideBlockBraces:
+  Enabled: false
+Layout/SpaceAroundOperators:
+  Enabled: false
+Layout/FirstHashElementIndentation:
+  Enabled: false
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+Layout/LeadingCommentSpace:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+Lint/UnderscorePrefixedVariableName:
+  Enabled: false

data/.yardopts

@@ -0,0 +1,10 @@
+--readme README.md
+--charset utf-8
+--markup-provider=redcarpet
+--markup=markdown
+--no-private
+--output-dir ./doc
+'lib/**/*.rb'
+-
+CHANGELOG.md
+LICENSE

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+## [0.1.1] - 2023-06-xx
+
+### Added
+### Fixed
+### Changed
+
+## [0.1.1] - 2023-06-06
+
+### Added
+  - Very first version, with support to migrate all the rake integrations.

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in eco-rake.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ecoPortal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# EcoRake
+
+A set of helpers to build re-usable `rake` integration helpers. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eco-rake', require: %w[eco-rake]
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eco-rake
+
+## Usage
+
+
+## Development
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+For more info on available `Rake` tasks: `rake -T`

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "yard"
+require "redcarpet"
+
+desc "run the specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "run rspec showing backtrace"
+RSpec::Core::RakeTask.new(:spec_trace) do |task|
+  task.rspec_opts = ['--backtrace']
+end
+
+desc "run rspec stopping on first fail, and show backtrace"
+RSpec::Core::RakeTask.new(:spec_fast) do |task|
+  task.rspec_opts = ['--fail-fast', '--backtrace']
+end
+
+# default task name is yard
+desc "Yard: generate all the documentation"
+YARD::Rake::YardocTask.new(:doc) do |t|
+  #t.files = ['lib/**/*.rb']
+end
+
+task default: [:spec]
+task rspec_trace: :spec_trace
+task rspec_fast: :spec_fast

data/eco-rake.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "eco-rake/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "eco-rake"
+  spec.version       = EcoRake::VERSION
+  spec.authors       = ["Oscar Segura Samper"]
+  spec.email         = ["oscar@ecoportal.co.nz"]
+
+  spec.summary       = 'A set of helpers to build re-usable `rake` integration helpers.'
+  spec.homepage      = "https://www.ecoportal.com"
+  spec.licenses      = %w[MIT]
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.7.2'
+
+  spec.add_development_dependency "bundler",   ">= 2.4.9",  "< 3"
+  spec.add_development_dependency "rake",      ">= 13.0.6", "< 14"
+  spec.add_development_dependency "redcarpet", ">= 3.6.0",  "< 4"
+  spec.add_development_dependency "rspec",     ">= 3.10.0", "< 4"
+  spec.add_development_dependency "yard",      ">= 0.9.34", "< 1"
+
+  #spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
+  spec.add_dependency 'aws-sdk-ses',    '>= 1.36.0', '< 2'
+  spec.add_dependency 'dotenv',         '>= 2.7.6',  '< 3'
+  spec.add_dependency 'rake-commander', '>= 0.3.6', "< 0.4"
+end

data/lib/eco-rake/base/method_helpers.rb

@@ -0,0 +1,55 @@
+class EcoRake
+  module Base
+    module MethodHelpers
+      # Calls `method` with just the parameters it requires
+      # @note missing arguments required arguments will be passed as `nil` value.
+      # @return the result of the call.
+      def safe_call(meth, *args, **kargs, &block)
+        msg = "Expecting Method or Proc. Given: #{meth.class}"
+        raise ArgumentError, msg unless [Method, Proc].any? {|c| meth.is_a?(c)}
+        aux_curry(meth, :safe).call(*args, **kargs, &block)
+      end
+
+      # @param meth [Method, Proc, Lambda]
+      # @param on_missing [Symbol] what should do when there are missing parameters
+      #   - `:curry`   -> it does a curry with the parameters received (default)
+      #   - `:call`    -> it calls anyway (will error).
+      #   - `:safe`    -> it sets to `nil` the missing required arguments and does a call.
+      #   - `:return`  -> it returns `nil` but doesn't call.
+      # @return [Lambda, NilClass, Result]
+      def aux_curry(meth, on_missing = :curry)
+        lambda do |*args, **kargs, &block|
+          params    = meth.parameters
+          kparams   = params.select  { |type, _| (type == :keyreq) || (type == :key) }
+          aparams   = params.select  { |type, _| (type == :req)    || (type == :opt) }
+
+          kreq_miss = kparams.select { |type, _| type == :keyreq }.map(&:last) - kargs.keys
+          req_miss  = aparams.select { |type, _| type == :req    }.count       - args.count
+          req_miss  = req_miss >= 0 ? req_miss : 0
+          ready     = kreq_miss.empty? && req_miss.zero?
+
+          if on_missing == :safe
+            argrest = params.find { |type, _| type == :rest }
+            keyrest = params.find { |type, _| type == :keyrest }
+            kextras = kargs.keys - kparams.map(&:last)
+            kextras.each { |name| kargs.delete(name) } unless keyrest
+            args = args[0..(aparams.count-1)]          unless argrest || args.count <= aparams.count
+            unless ready
+              kreq_miss.each { |name| kargs[name] = nil }
+              ary_nil = Array.new(req_miss, nil)
+              args    = args.dup.push(*ary_nil)
+              ready   = true
+            end
+          end
+          return meth.call(*args, **kargs, &block) if ready || on_missing == :call
+          return nil                               if on_missing == :return
+          # (default) on_missing == :curry
+          lambda do |*oth, **koth, &blk|
+            curried = aux_curry(meth, on_missing)
+            curried[*args, *oth, **kargs, **koth, &(blk || block)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/base/symbol_resolver.rb

@@ -0,0 +1,82 @@
+class EcoRake
+  module Base
+    module SymbolResolver
+      include EcoRake::Base::MethodHelpers
+
+      # i.e. value = `:default_value` -> `'DEFAULT_VALUE'`
+      def constant_name(value)
+        case value
+        when String
+          value.strip.upcase
+        when Symbol
+          constant_name(value.to_s)
+        end
+      end
+
+      # Wraps a symbol to be resolved lazyly.
+      # @note the resolution process goes in this order
+      #   1. First try on the `invoker` and its class.
+      #   2. Final on the `definer` and its class.
+      # @return [Proc] a callback that will resolve the symbol.
+      def symbol_resolver(sym, as: %i[method const])
+        definer = self
+        proc do |invoker|
+          resolution = invoker.instance_eval do
+            definer.resolve_symbol(sym, source: invoker, as: as)
+          end
+          resolution ||= definer.resolve_symbol(sym, source: definer, as: as)
+          resolution
+        end
+      end
+
+      # @param sym [Symbol, String] that we try to resolve to a value of a constant.
+      # @param as [Symbol, Array<Symbol>] the order in which it should try to look up.
+      # @return [Method, Value, NilClass] either the value of constant, a method or `nil`
+      #   if not found.
+      def resolve_symbol(sym, source: self, as: %i[method const])
+        as = [as].flatten.compact
+        as.reduce(nil) do |value, type|
+          case type
+          when :const
+            value || resolve_const(sym, source: source)
+          when :method
+            value || resolve_method(sym, source: source)
+          end
+        end
+      end
+
+      # @param sym [Symbol, String] that we try to resolve to a value of a constant.
+      # @return [Value, NilClass] `nil` when unresolved, the value of the constant otherwise.
+      def resolve_const(sym, source: self)
+        return nil unless sym.is_a?(Symbol) || sym.is_a?(String)
+        sym = constant_name(sym)
+        value   = nil
+        value ||= safe_const_get(sym, klass: source)
+        value ||= safe_const_get(sym, klass: Kernel)
+        value
+      rescue NameError
+        nil
+      end
+
+      # @note it does not raise ErrorName
+      # @return [Value, NilClass] returns `nil` if const not defined or the value of the constant.
+      def safe_const_get(name, klass: self)
+        klass = klass.class unless klass.is_a?(Class) || klass == Kernel
+        klass.const_get(name) if klass.const_defined?(name)
+      rescue NameError
+        nil
+      end
+
+      # @param sym [Symbol, String] that we try to resolve to a method.
+      # @return [Method, NilClass] `nil` when unresolved, the `method` otherwise.
+      def resolve_method(sym, source: self)
+        return nil unless sym.is_a?(Symbol) || sym.is_a?(String)
+        meth = source.method(sym) if source.respond_to?(sym, true)
+        return meth if meth
+        return nil  if source.is_a?(Class)
+        return nil  unless source.class.respond_to?(sym, true)
+        source.class.method(sym)
+      end
+    end
+  end
+end

data/lib/eco-rake/base.rb

@@ -0,0 +1,25 @@
+require_relative 'base/method_helpers'
+require_relative 'base/symbol_resolver'
+require_relative 'default'
+require_relative 'utils'
+require_relative 'shell'
+require_relative 'rake_task'
+require_relative 'option'
+require_relative 'options'
+
+class EcoRake
+  module Base
+    class << self
+      def included(base)
+        super(base)
+        base.autoloads_children_of RakeCommander
+        base.extend ClassMethods
+        base.send :include, RakeTask
+        base.send :include, Options
+      end
+    end
+
+    module ClassMethods
+    end
+  end
+end

data/lib/eco-rake/custom.rb

@@ -0,0 +1,5 @@
+# Provides a namespace to declare task classes
+class EcoRake
+  module Custom
+  end
+end

data/lib/eco-rake/default/const.rb

@@ -0,0 +1,46 @@
+class EcoRake
+  module Default
+    module Const
+      class << self
+        def included(base)
+          super(base)
+          base.extend EcoRake::Base::SymbolResolver
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        # Creates (overridable) method(s) that link to an expected constant with same name (in capitals).
+        # @note this creates one method on the class and one on instances thereof.
+        # @param required [Boolean] whether an exception should be raised if the constant does not exist
+        #   when the created method is called.
+        # @param override [Boolean] whether an exception should NOT be raised if the method exists.
+        # @param default [Variant] whether if this defaults to some value (won't raise NameError).
+        def attr_const(*attrs, required: false, override: false, default: :not_used)
+          attrs.each do |attr|
+            attr = attr.to_s.freeze
+
+            unless override
+              msg  = "#{__method__} does not allow method override. Offending attr: #{attr}"
+              raise ArgumentError, "#{msg} (class method)"    if methods.include?(attr)
+              raise ArgumentError, "#{msg} (instance method)" if instance_methods.include?(attr)
+            end
+
+            define_singleton_method attr do
+              msg   = "Missing const '#{attr.to_s.upcase}' in #{self}"
+              value = resolve_const(attr)
+              value = default      if value.nil? && default != :not_used
+              raise NameError, msg if value.nil? && required
+              yield(value) if block_given?
+              value
+            end
+
+            define_method attr do |&block|
+              self.class.send(attr, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/default.rb

@@ -0,0 +1,12 @@
+require_relative 'default/const'
+
+class EcoRake
+  module Default
+    class << self
+      def included(base)
+        super(base)
+        base.send :include, Const
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/base_task.rb

@@ -0,0 +1,9 @@
+class EcoRake
+  module Lib
+    # Class with libs to ease task built
+    class BaseTask < EcoRake
+      include EcoRake::Utils
+      include EcoRake::Shell
+    end
+  end
+end

data/lib/eco-rake/lib/concern/base.rb

@@ -0,0 +1,21 @@
+class EcoRake
+  module Sample
+    module Concern
+      module Base
+        class << self
+          def included(base)
+            super(base)
+            base.extend ClassMethods
+          end
+        end
+
+        module ClassMethods
+          def included(base)
+            super(base)
+            base.extend self::ClassMethods if defined?(self::ClassMethods)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/concern/enviro.rb

@@ -0,0 +1,23 @@
+class EcoRake
+  module Sample
+    module Concern
+      module Enviro
+        include EcoRake::Sample::Concern::Base
+
+        class << self
+          def included(base)
+            super(base)
+            base.option '-e', '--enviro ENVIRO', default_lookup: :default_enviro
+          end
+        end
+
+        module ClassMethods
+          def default_enviro
+            raise "Missing const 'DEFAULT_ENVIRO'" unless defined?(self::DEFAULT_ENVIRO)
+            self::DEFAULT_ENVIRO
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/concern/local_folder.rb

@@ -0,0 +1,23 @@
+class EcoRake
+  module Sample
+    module Concern
+      module LocalFolder
+        include EcoRake::Sample::Concern::Base
+
+        class << self
+          def included(base)
+            super(base)
+            base.option '-d', '--folder NAME', default_lookup: :default_local_folder, desc: 'Source local folder'
+          end
+        end
+
+        module ClassMethods
+          def default_local_folder
+            return '.' unless defined?(self::DEFAULT_LOCAL_FOLDER)
+            self::DEFAULT_LOCAL_FOLDER
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/concern/person_schema.rb

@@ -0,0 +1,24 @@
+class EcoRake
+  module Sample
+    module Concern
+      # It adds the configurable option person schema
+      module PersonSchema
+        include EcoRake::Sample::Concern::Base
+
+        class << self
+          def included(base)
+            super(base)
+            base.option '-c', '--schema NAME', default_lookup: :default_person_schema, desc: "Target person schema."
+          end
+        end
+
+        module ClassMethods
+          def default_person_schema
+            raise "Missing const 'DEFAULT_PERSON_SCHEMA'" unless defined?(self::DEFAULT_PERSON_SCHEMA)
+            self::DEFAULT_PERSON_SCHEMA
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/concern.rb

@@ -0,0 +1,11 @@
+require_relative 'concern/base'
+require_relative 'concern/enviro'
+require_relative 'concern/person_schema'
+require_relative 'concern/local_folder'
+
+class EcoRake
+  module Sample
+    module Concern
+    end
+  end
+end