ansible-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cf644b0026a9957bf3a48014ca6be7fbef7754f
+  data.tar.gz: 5d995328dab9f7ef92b4d19d62f865b6f7ea59ed
+SHA512:
+  metadata.gz: e40e14ee5efc2456c80ad564317b4e9a4bb67a2df06c71a3d25b973e2e54dd5cfe77150afee914eef5d6462baeb1ead0c6b526c06d0d8c73a0f8fe8638ef9d49
+  data.tar.gz: 491ba9587200bc0a5d45cbe2738d413a99bfab91efa5339b7c10769e9c57ba58b12b5c9313bf714b86a224a635aae819d90f959fb2444cfe884e63672ed5d102

data/lib/ansible-ruby.rb

@@ -0,0 +1,7 @@
+# rubocop:disable Style/FileName
+# This is the name of the GEM, need it this way
+require 'ansible/ruby/version'
+require 'ansible/ruby/serializer'
+require 'ansible/ruby/dsl_builders/file_level'
+require 'ansible/ruby/modules/generated'
+# rubocop:enable Style/FileName

data/lib/ansible/ruby/dsl_builders/args.rb

@@ -0,0 +1,19 @@
+require 'ansible/ruby/dsl_builders/base'
+
+module Ansible
+  module Ruby
+    module DslBuilders
+      class Args < Base
+        def initialize
+          super
+          @result = {}
+        end
+
+        def process_method(id, *args)
+          value = args.length == 1 ? args[0] : args
+          @result[id] = value
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/base.rb

@@ -0,0 +1,54 @@
+module Ansible
+  module Ruby
+    module DslBuilders
+      class Base
+        def initialize
+          @result = nil
+        end
+
+        attr_reader :result
+
+        def evaluate(*args, &block)
+          if block
+            instance_eval(&block)
+          else
+            raise 'Expected code as an argument if no block supplied!' unless args.length == 1
+            instance_eval args[0]
+          end
+          @result
+        end
+
+        def respond_to_missing?(*)
+          super
+        end
+
+        def method_missing(id, *args, &block)
+          result = begin
+            process_method id, *args, &block
+          rescue StandardError => our_error
+            begin
+              super
+            rescue NoMethodError => ruby_error
+              matching_line = ruby_error.backtrace
+                                        .map { |str| str.split ':' }
+                                        .find { |arr| arr[0] == '(eval)' }[1]
+              raise "#{our_error.message} at line #{matching_line}!"
+            end
+          end
+          method_missing_return id, result, *args
+        end
+
+        private
+
+        def method_missing_return(*)
+          # Don't leak return values
+          nil
+        end
+
+        def implicit_bool(args)
+          args.empty? || args[0]
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/file_level.rb

@@ -0,0 +1,52 @@
+require 'ansible/ruby/dsl_builders/play'
+require 'ansible/ruby/models/playbook'
+require 'ansible/ruby/models/tasks'
+
+module Ansible
+  module Ruby
+    module DslBuilders
+      class FileLevel < Base
+        def initialize
+          @plays = []
+          @tasks_builder = nil
+          @context = nil
+        end
+
+        def play(name = nil, &block)
+          if @context == :tasks
+            raise 'This is a tasks file due to a task coming before this play, cannot use play here!'
+          end
+          @context = :playbook
+          play_builder = Play.new name
+          @plays << play_builder.evaluate(&block)
+        end
+
+        def task(name, &block)
+          if @context == :playbook
+            raise 'This is a playbook file due to a play coming before this task, cannot use task here!'
+          end
+          @context = :tasks
+          @tasks_builder ||= Tasks.new
+          @tasks_builder.task name, &block
+        end
+
+        def evaluate(*)
+          super
+          case @context
+          when :playbook
+            # TODO: Add a playbook DSL and do this like tasks
+            Models::Playbook.new plays: @plays
+          when :tasks
+            @tasks_builder.evaluate {}
+          else
+            raise "Unknown context #{@context}"
+          end
+        end
+
+        def process_method(id, *)
+          raise "undefined local variable or method `#{id}'"
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/module_call.rb

@@ -0,0 +1,50 @@
+require 'ansible/ruby/dsl_builders/base'
+require 'ansible/ruby/dsl_builders/args'
+require 'ansible/ruby/modules/base'
+require 'ansible/ruby/modules/custom/free_form'
+
+module Ansible
+  module Ruby
+    module DslBuilders
+      class ModuleCall < Base
+        MODULES_MOD = Ansible::Ruby::Modules
+
+        def respond_to_missing?(method_name, _)
+          klass_name = klass_name method_name
+          MODULES_MOD.const_defined?(klass_name) || super
+        end
+
+        private
+
+        def klass_name(id)
+          id.to_s.capitalize
+        end
+
+        def process_method(id, *module_args, &block)
+          raise "Unknown module #{id}" unless respond_to_missing? id, true
+          module_klass = MODULES_MOD.const_get klass_name(id)
+          free_form_module = module_klass.include?(Ansible::Ruby::Modules::FreeForm)
+          if module_args.any? && !free_form_module
+            raise "Can't use arguments #{module_args} on this type of module"
+          end
+          free_form = free_form_arg(module_args) if free_form_module
+          # Delegate everything to the args builder and apply it to the module class we located
+          module_builder = Args.new
+          args = module_builder.evaluate(&block)
+          args[:free_form] = free_form if free_form
+          @result = module_klass.new(args)
+          @result.validate!
+        end
+
+        def free_form_arg(module_args)
+          if module_args.any?
+            raise 'Expected only 1 argument for this type of module' if module_args.length > 1
+            module_args[0]
+          else
+            raise 'Expected 1 argument for this type of module'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/play.rb

@@ -0,0 +1,53 @@
+require 'ansible/ruby/models/play'
+require 'ansible/ruby/dsl_builders/tasks'
+
+module Ansible
+  module Ruby
+    module DslBuilders
+      class Play < Tasks
+        def initialize(name = nil)
+          super()
+          @playbook_args = {}
+          @playbook_args[:name] = name
+        end
+
+        def hosts(value)
+          @playbook_args[:hosts] = value
+        end
+
+        def roles(value)
+          @playbook_args[:roles] = value
+        end
+
+        def connection(value)
+          @playbook_args[:connection] = value
+        end
+
+        def user(value)
+          @playbook_args[:user] = value
+        end
+
+        def serial(value)
+          @playbook_args[:serial] = value
+        end
+
+        def gather_facts(value)
+          @playbook_args[:gather_facts] = value
+        end
+
+        def local_host
+          hosts 'localhost'
+          connection :local
+        end
+
+        def evaluate(*)
+          tasks = super
+          args = @playbook_args.merge({})
+          # Don't want to trigger validation
+          args[:tasks] = tasks if tasks.tasks.any?
+          Models::Play.new args
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/result.rb

@@ -0,0 +1,33 @@
+module Ansible
+  module Ruby
+    module DslBuilders
+      class Result
+        def initialize(counter, register_set)
+          @name = "result_#{counter}"
+          # Until the variable is utilized, we don't know if 'register' should be set, the supplied lambda
+          # allows us to set register on the task
+          @register_set = register_set
+        end
+
+        # we need to respond to everything, don't want super
+        # rubocop:disable Style/MethodMissing
+        def method_missing(id, *args)
+          register_needed
+          flat_args = args.map(&:inspect).map(&:to_s).join ', '
+          "#{@name}.#{id}#{flat_args.empty? ? '' : "(#{flat_args})"}"
+        end
+        # rubocop:enable Style/MethodMissing
+
+        def respond_to_missing?(*)
+          true
+        end
+
+        private
+
+        def register_needed
+          @register_set[@name]
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/task.rb

@@ -0,0 +1,94 @@
+require 'ansible/ruby/dsl_builders/base'
+require 'ansible/ruby/dsl_builders/module_call'
+require 'ansible/ruby/dsl_builders/result'
+require 'ansible/ruby/models/task'
+
+module Ansible
+  module Ruby
+    module DslBuilders
+      class Task < Base
+        def initialize(name)
+          super()
+          @module = nil
+          @temp_counter = 0
+          @name = name
+          @task_args = {}
+        end
+
+        def evaluate(*)
+          super
+          args = {
+            module: @module,
+            name: @name
+          }.merge @task_args
+          task = Models::Task.new args
+          task.validate!
+          task
+        end
+
+        def become(*args)
+          value = implicit_bool args
+          @task_args[:become] = value
+        end
+
+        def become_user(value)
+          @task_args[:become_user] = value
+        end
+
+        def changed_when(clause)
+          @task_args[:changed_when] = clause
+        end
+
+        def failed_when(clause)
+          @task_args[:failed_when] = clause
+        end
+
+        def ansible_when(clause)
+          @task_args[:when] = clause
+        end
+
+        def with_dict(clause)
+          @task_args[:with_dict] = clause
+        end
+
+        def async(value)
+          @task_args[:async] = value
+        end
+
+        def poll(value)
+          @task_args[:poll] = value
+        end
+
+        def notify(value)
+          @task_args[:notify] = value
+        end
+
+        def ignore_errors(*args)
+          value = implicit_bool args
+          @task_args[:ignore_errors] = value
+        end
+
+        def respond_to_missing?(*)
+          !@module || super
+        end
+
+        private
+
+        def process_method(id, *args, &block)
+          # only 1 module, so don't try and do this again
+          raise "undefined local variable or method `#{id}'" if @module
+          module_call_builder = ModuleCall.new
+          module_call_builder.send(id, *args, &block)
+          @module = module_call_builder.result
+        end
+
+        def method_missing_return(_id, _result, *_args)
+          # method_missing only used for modules here
+          # Keep our register variables unique
+          @temp_counter += 1
+          Result.new(@temp_counter, ->(name) { @task_args[:register] = name })
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/dsl_builders/tasks.rb

@@ -0,0 +1,28 @@
+# See LICENSE.txt for license
+require 'ansible/ruby/dsl_builders/task'
+
+module Ansible
+  module Ruby
+    module DslBuilders
+      class Tasks < Base
+        def initialize
+          @tasks = []
+        end
+
+        def task(name, &block)
+          task_builder = Task.new name
+          @tasks << task_builder.evaluate(&block)
+        end
+
+        def evaluate(*)
+          super
+          Models::Tasks.new tasks: @tasks
+        end
+
+        def process_method(id, *)
+          raise "undefined local variable or method `#{id}'"
+        end
+      end
+    end
+  end
+end

data/lib/ansible/ruby/models/base.rb

@@ -0,0 +1,83 @@
+require 'active_model'
+require 'ansible/ruby/models/type_generic'
+require 'ansible/ruby/models/multiple_types'
+require 'ansible/ruby/models/type_validator'
+
+module Ansible
+  module Ruby
+    module Models
+      class Base
+        include ActiveModel::Model
+        include ActiveModel::Validations
+
+        def initialize(args = {})
+          super
+          @set_vars = args.keys
+        end
+
+        class << self
+          def attribute(name, options = {})
+            attr_accessor name
+            @attr_options ||= {}
+            for_name = @attr_options[name] ||= {}
+            for_name.merge! options
+          end
+
+          def attr_options(name)
+            @attr_options[name]
+          end
+
+          def validates(*attributes)
+            super
+            # avoid having to dupe this in the :attribute call
+            hash = attributes.length > 1 && attributes[1]
+            type_validator = hash && hash[:type]
+            return unless type_validator
+            if type_validator.is_a?(TypeGeneric)
+              name = attributes[0]
+              for_name = @attr_options[name] ||= {}
+              for_name[:generic] = type_validator.klass
+            end
+          end
+        end
+
+        def to_h
+          validate!
+          Hash[
+            @set_vars.map do |key|
+              value = send key
+              options = self.class.attr_options(key)
+              value = hashify value
+              generic_type = options[:generic]
+              value = convert_generic generic_type, value if generic_type
+              key = options[:original_name] || key
+              [key, value]
+            end.compact]
+        end
+
+        private
+
+        def hashify(value)
+          case value
+          when Array
+            value.map { |val| val.respond_to?(:to_h) ? val.to_h : val }
+          when Base
+            value.to_h
+          else
+            value
+          end
+        end
+
+        def convert_generic(generic_type, value)
+          # hash friendly of [*value]
+          case value
+          when generic_type
+            [value]
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end