stack_master 1.6.0-x64-mingw32

data/lib/stack_master/sparkle_formation/compile_time/allowed_values_validator.rb

@@ -0,0 +1,37 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class AllowedValuesValidator < ValueValidator
+
+        KEY = :allowed_values
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.reject do |value|
+            @definition[KEY].any? { |allowed_value| allowed_value.to_s == value.to_s}
+          end
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} is not in #{KEY}:#{@definition[KEY]}"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/definitions_validator.rb

@@ -0,0 +1,33 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class DefinitionsValidator
+
+        VALID_TYPES = [:string, :number]
+        def initialize(definitions)
+          @definitions = definitions
+        end
+
+        def validate
+          @definitions.each do|name, definition|
+            type = definition[:type]
+            raise ArgumentError.new "Unknown compile time parameter type: #{create_error(name, type)}" unless is_valid(type)
+          end
+        end
+
+        private
+
+        def is_valid(type)
+          VALID_TYPES.include? type
+        end
+
+        def create_error(name, type)
+          "#{name}:#{type} valid types are #{VALID_TYPES}"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/empty_validator.rb

@@ -0,0 +1,32 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class EmptyValidator < ValueValidator
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          !has_invalid_values?
+        end
+
+        def has_invalid_values?
+          values = build_values(@definition, @parameter)
+          values.include?(nil) || values.include?('')
+        end
+
+        def create_error
+          "#{@name} cannot contain empty parameters:#{@parameter.inspect}"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/max_length_validator.rb

@@ -0,0 +1,36 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class MaxLengthValidator < ValueValidator
+
+        KEY = :max_length
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :string
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.select { |values| values.length > @definition[KEY].to_i }
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} must not exceed #{KEY}:#{@definition[KEY]} characters"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/max_size_validator.rb

@@ -0,0 +1,36 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class MaxSizeValidator < ValueValidator
+
+        KEY = :max_size
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :number
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.select { |value| value.to_f > @definition[KEY].to_f }
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} must not be greater than #{KEY}:#{@definition[KEY]}"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/min_length_validator.rb

@@ -0,0 +1,36 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class MinLengthValidator < ValueValidator
+
+        KEY = :min_length
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :string
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.select { |value| value.length < @definition[KEY].to_i}
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} must be at least #{KEY}:#{@definition[KEY]} characters"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/min_size_validator.rb

@@ -0,0 +1,36 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class MinSizeValidator < ValueValidator
+
+        KEY = :min_size
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :number
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.select { |value| value.to_f < @definition[KEY].to_f}
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} must not be lesser than #{KEY}:#{@definition[KEY]}"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/number_validator.rb

@@ -0,0 +1,35 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class NumberValidator < ValueValidator
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :number
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.reject do |value|
+            value.is_a?(Numeric) || value.is_a?(String) && value.to_s =~ /^(\d+)(\.?(\d+))?$/
+          end
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} are not Numbers"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/parameters_validator.rb

@@ -0,0 +1,27 @@
+require_relative 'value_validator_factory'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ParametersValidator
+
+        def initialize(definitions, parameters)
+          @definitions = definitions
+          @parameters = parameters
+        end
+
+        def validate
+          @definitions.each do |name, definition|
+            parameter = @parameters[name.to_s.camelize]
+            factory = ValueValidatorFactory.new(name, definition, parameter)
+            value_validators = factory.build
+            value_validators.each do |validator|
+              validator.validate
+              raise ArgumentError.new "Invalid compile time parameter: #{validator.error}" unless validator.is_valid
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/state_builder.rb

@@ -0,0 +1,32 @@
+require_relative 'value_builder'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class StateBuilder
+
+        def initialize(definitions, parameters)
+          @definitions = definitions
+          @parameters = parameters
+        end
+
+        def build
+          state = {}
+          @definitions.each do |name, definition|
+            parameter_key = name.to_s.camelize
+            parameter = @parameters[parameter_key]
+            state[name] = create_value(definition, parameter)
+          end
+          state
+        end
+
+        private
+
+        def create_value(definition, parameter)
+          ValueBuilder.new(definition, parameter).build
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/string_validator.rb

@@ -0,0 +1,33 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class StringValidator < ValueValidator
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :string
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.reject { |value| value.is_a?(String)}
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} are not Strings"
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/value_builder.rb

@@ -0,0 +1,40 @@
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ValueBuilder
+
+        def initialize(definition, parameter)
+          @definition = definition
+          @parameter = parameter
+        end
+
+        def build
+          parameter_or_default
+          convert_strings_to_array
+          convert_strings_to_numbers
+          @value
+        end
+
+        private
+
+        def parameter_or_default
+          @value = @parameter.nil? ? @definition[:default] : @parameter
+        end
+
+        def convert_strings_to_array
+          if @definition[:multiple] && @value.is_a?(String)
+            @value = @value.split(',').map(&:strip)
+          end
+        end
+
+        def convert_strings_to_numbers
+          if @definition[:type] == :number
+            @value = @value.to_f if @value.is_a?(String)
+            @value = @value.map { |item| item.is_a?(String) ? item.to_f : item } if @value.is_a?(Array)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/compile_time/value_validator.rb

@@ -0,0 +1,40 @@
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ValueValidator
+
+        attr_reader :is_valid, :error
+
+        def validate
+          @is_valid = check_is_valid
+          @error = create_error unless @is_valid
+        end
+
+        protected
+
+        def check_is_valid
+          raise NotImplementedError
+        end
+
+        def create_error
+          raise NotImplementedError
+        end
+
+        def build_values(definition, parameter)
+          parameter_or_default = parameter.nil? ? definition[:default] : parameter
+          convert_to_array(definition, parameter_or_default)
+        end
+
+        private
+
+        def convert_to_array(definition, parameter)
+          if definition[:multiple] && parameter.is_a?(String)
+            return parameter.split(',').map(&:strip)
+          end
+          parameter.is_a?(Array) ? parameter : [parameter]
+        end
+
+      end
+    end
+  end
+end