rake-opt-keyword_args 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDk0MWYzYzMzMGQzYjY2YmQwM2E4ODE2MDM0OWIwMTI5NDc4YTVmMg==
+  data.tar.gz: !binary |-
+    MDlmM2UwOGI1ODczMTU0YmFkMmQ1OGVhMDcwNGI5Y2UzMDBmOTUzNg==
+SHA512:
+  metadata.gz: !binary |-
+    YTAwMzA2OThiYTU5ZDVmNWYzODllZTg2NjYxNzYyNWYxYmJjMTk4ODMwNTc4
+    NjVjN2I2MDdiY2IxZDdiNTFiYTMxYzc3NDRkOGM5OTMzZmQ4MDY3OTQ3NWM2
+    MTdiODg5NWZlM2E0ZTc3ZDEzYTQzMDhlOTM1YTVhMzUzYWFiM2U=
+  data.tar.gz: !binary |-
+    ZTljZDRhY2JlYjhlNmFkMzBjNzU4ZWY3Yjc0NGNhM2QxZWNhMmUzMTliOTVi
+    YTZlOTUzNWRkYmZmNzM2ODQ3NDkzNDlmMTQ4ODY4OTk3NTUyNjAzOWI3Mzhi
+    NzIwYTI4ZjA4NzQ5NjFkNzliYTU4M2RiNzE5ZjM4ZDQ5MmJlM2E=

data/lib/rake/opt/keyword_args.rb

@@ -0,0 +1,196 @@
+require 'active_support/all'
+require 'hashie'
+
+module Rake
+  module Opt
+    module KeywordArgs
+      PARAM_SEPARATOR = ' '
+
+      class Error < StandardError ; end
+      class DefinitionError < Error ; end
+      class ValidationError < Error ; end
+      class UnsupportedTypeError < Error ; end
+
+      def self.included base
+        base.send :include, InstanceMethods
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def verify_args_block
+          # Flush the Print Queue at the end of each iteration
+          lambda do |*args|
+            task = args.first
+            yield task, task.verify_args(args[1]) if block_given?
+          end
+        end
+
+        def define_parameterized_task(*args, &block)
+          arg_options = Rake.application.last_args
+          Rake.application.last_args = nil
+          # Parse the arguments
+          name = ''
+          requirements = []
+          case args.size
+          when 1 then
+            arg = args.first
+            if arg.is_a? Hash
+              name = arg.keys.first
+              requirements = arg.values.first
+            else
+              name = arg.to_s
+            end
+          when 2 then
+            name = args.first
+            deps = args.last
+            if deps.is_a? Hash
+              if deps.keys.first.empty?
+                requirements = deps.values.last
+              else
+                raise DefinitionError, 'Must have no arguments when defining a paramterized task'
+              end
+            else
+              raise DefinitionError, 'Must have no arguments when defining a paramterized task'
+            end
+          else
+            raise DefinitionError, 'Unknown argument format'
+          end
+
+          # Set the pseudo args
+          arg_options_str = arg_options.keys.sort do |x,y|
+            next -1 if arg_options[x][:required] && !arg_options[y][:required]
+            next 1 if !arg_options[x][:required] && arg_options[y][:required]
+            next 1 if arg_options[x][:default] && !arg_options[y][:default]
+            next -1 if !arg_options[x][:default] && arg_options[y][:default]
+            next x.to_s <=> y.to_s
+          end.map do |arg|
+            options = arg_options[arg]
+            if options[:default] != nil
+              default_str = options[:default].to_s
+            elsif options[:required]
+              default_str = 'REQUIRED'
+            else
+              default_str = 'nil'
+            end
+            next "#{arg}=#{default_str}"
+          end.join(PARAM_SEPARATOR)
+          task_args = [ name, { [arg_options_str] => requirements } ]
+
+          task = self.__define_task_before_keyword_args__(*task_args, &verify_args_block(&block))
+
+          task.arg_options = arg_options
+
+          return task
+        end
+
+      end
+
+      module InstanceMethods
+        attr_accessor :arg_options
+
+        def parse_args(args)
+          raise Error, 'Expected only one argument'  if args.count > 1
+          args = (args.first && args.first.last) ? args.first.last : ''
+          parsed_args = Hashie::Mash.new
+          args.split(PARAM_SEPARATOR).each do |pair|
+            arg, value = pair.split('=', 2)
+            parsed_args[arg] = value.blank? ? nil : value
+          end
+
+          return parsed_args
+        end
+
+        def verify_args(args)
+          return args unless self.arg_options
+
+          parsed_args = self.parse_args(args)
+          output = Hashie::Mash.new
+          self.arg_options.each do |arg_name, options|
+            # Extract Value if it's set, otherwise, use the default
+            if parsed_args[arg_name]
+              value = parsed_args[arg_name]
+            else
+              value = options[:default]
+            end
+
+            # Cast the argument to the proper type
+            if value.nil?
+            # Keep it as nil
+            elsif [Fixnum, Integer].include? options[:class]
+              value = value.to_i
+            elsif Float == options[:class]
+              value = value.to_f
+            elsif Symbol == options[:class]
+              value = value.to_sym
+            elsif Rational == options[:class]
+              value = value.to_r
+            elsif [String, nil].include? options[:class]
+              value = value.to_s
+            elsif Boolean == options[:class]
+              value = %w{ 1 true yes t }.include? value.to_s.downcase
+            else
+              raise UnsupportedTypeError, "Arguments of type #{options[:class]} are not supported"
+            end
+
+            # Set the output value
+            output[arg_name] = value
+
+            if options[:required] && output[arg_name].nil? && !Rake.application.options.dryrun
+              raise ValidationError, "Argument :#{arg_name} is required for Task #{self.name}"
+            end
+          end
+          return output
+        end
+
+        def verify_and_merge_args(args)
+          verified = verify_args(args)
+          return self.parse_args(args).merge(verified)
+        end
+
+        def arg_hash_to_str(hash)
+          args = ''
+          hash.each{ |k, v| args << "#{k}=#{v} " }
+          return args.strip
+        end
+
+        private
+        def extract_prerequisite_args(task_args, p)
+          merged_args = self.verify_and_merge_args(task_args)
+          if p.arg_options
+            prereq_args = Rake::TaskArguments.new(p.arg_names, [self.arg_hash_to_str(merged_args)])
+            p.verify_args(prereq_args)
+          else
+            prereq_args = task_args.new_scope(p.arg_names)
+          end
+          return prereq_args
+        end
+
+        def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
+          if application.options.always_multitask
+            invoke_prerequisites_concurrently(task_args, invocation_chain)
+          else
+            prerequisite_tasks.each do |p|
+              merged_args = self.verify_and_merge_args(task_args)
+              p.invoke_with_call_chain(extract_prerequisite_args(task_args,p), invocation_chain)
+            end
+          end
+        end
+
+        def invoke_prerequisites_concurrently(task_args, invocation_chain)# :nodoc:
+          futures = prerequisite_tasks.map do |p|
+            merged_args = self.verify_and_merge_args(task_args)
+            application.thread_pool.future(p) do |r|
+              r.invoke_with_call_chain(extract_prerequisite_args(task_args,p), invocation_chain)
+            end
+          end
+          futures.each { |f| f.value }
+        end
+
+      end
+    end
+  end
+end
+
+require_relative 'keyword_args/patches.rb'
+

data/lib/rake/opt/keyword_args/patches.rb

@@ -0,0 +1,4 @@
+require_relative 'patches/boolean.rb'
+require_relative 'patches/rake/application.rb'
+require_relative 'patches/rake/dsl.rb'
+require_relative 'patches/rake/task.rb'

data/lib/rake/opt/keyword_args/patches/boolean.rb

@@ -0,0 +1 @@
+class Boolean ; end

data/lib/rake/opt/keyword_args/patches/rake/application.rb

@@ -0,0 +1,6 @@
+require 'rake/application'
+
+class Rake::Application
+  attr_accessor :last_args
+  attr_accessor :current_task
+end

data/lib/rake/opt/keyword_args/patches/rake/dsl.rb

@@ -0,0 +1,17 @@
+require_relative 'task.rb'
+
+require 'rake/opt/keyword_args'
+
+module Rake::DSL
+
+  # Define a task with keyword args
+  def args(args_options)
+    # Set defaults
+    args_options.each do |arg, options|
+      raise ArgumentError, "No options set for argument #{arg}", caller[2..-1] unless options
+      options[:required] ||= options[:required].nil? && options[:default].nil?
+    end
+    Rake.application.last_args = args_options
+  end
+
+end

data/lib/rake/opt/keyword_args/patches/rake/task.rb

@@ -0,0 +1,61 @@
+require 'rake/task'
+
+class Rake::Task
+  include Rake::Opt::KeywordArgs
+
+  # Save the original invoke instance method
+  alias_method "__invoke_before_keyword_args__", "invoke"
+
+  def invoke (*args)
+    if self.arg_options && args.first.is_a?(Hash)
+      self.__invoke_before_keyword_args__(arg_hash_to_str(args.first))
+    else
+      self.__invoke_before_keyword_args__(*args)
+    end
+  end
+
+  # Save the original execute instance method
+  alias_method "__execute_before_keyword_args__", "execute"
+
+  def execute (*args)
+    if self.arg_options && args.first.is_a?(Hash)
+      self.__execute_before_keyword_args__(Rake::TaskArguments.new(arg_names, [arg_hash_to_str(args.first)]))
+    else
+      self.__execute_before_keyword_args__(*args)
+    end
+  end
+
+  def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
+    if application.options.always_multitask
+      invoke_prerequisites_concurrently(task_args, invocation_chain)
+    else
+      prerequisite_tasks.each do |p|
+        merged_args = self.verify_and_merge_args(task_args)
+        p.invoke_with_call_chain(extract_prerequisite_args(task_args,p), invocation_chain)
+      end
+    end
+  end
+
+  def invoke_prerequisites_concurrently(task_args, invocation_chain)# :nodoc:
+    futures = prerequisite_tasks.map do |p|
+      merged_args = self.verify_and_merge_args(task_args)
+      application.thread_pool.future(p) do |r|
+        r.invoke_with_call_chain(extract_prerequisite_args(task_args,p), invocation_chain)
+      end
+    end
+    futures.each { |f| f.value }
+  end
+
+  class << self
+    # Save the original define_task module method
+    alias_method "__define_task_before_keyword_args__", "define_task"
+    def define_task(*args, &block)
+      if Rake.application.last_args
+        return define_parameterized_task(*args, &block)
+      else
+        return self.__define_task_before_keyword_args__(*args, &block)
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: rake-opt-keyword_args
+version: !ruby/object:Gem::Version
+  version: !binary |-
+    MC4xLjA=
+platform: ruby
+authors:
+- Jon San Miguel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MTAuMy4y
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MTAuMy4y
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          Mi4xLjE=
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          Mi4xLjE=
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          NC4xLjE=
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          NC4xLjE=
+description: Adds keyword arg system to rake tasks
+email: jon.sanmiguel@optimizely.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rake/opt/keyword_args.rb
+- lib/rake/opt/keyword_args/patches.rb
+- lib/rake/opt/keyword_args/patches/boolean.rb
+- lib/rake/opt/keyword_args/patches/rake/application.rb
+- lib/rake/opt/keyword_args/patches/rake/dsl.rb
+- lib/rake/opt/keyword_args/patches/rake/task.rb
+homepage: http://rubygems.org/gems/rake-opt-keyword_args
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Adds keyword arg system to rake tasks
+test_files: []