anodator 1.0.0.pre1 → 1.0.0.pre2

data/lib/anodator/checker.rb

@@ -1,48 +1,55 @@
-require "anodator/input_spec"
-require "anodator/rule_set"
-require "anodator/output_spec"
-require "anodator/anodator_error"
+require 'anodator/input_spec'
+require 'anodator/rule_set'
+require 'anodator/output_spec'
+require 'anodator/data_source_set'
+require 'anodator/anodator_error'
 
 module Anodator
+  # Checker class.
   class Checker
-    def initialize(input_spec, rule_set, default_output_spec, configuration_check = false)
-      @input_spec   = input_spec
-      @rule_set     = rule_set
-      @output_specs = [default_output_spec]
+    include Common
 
-      unless @input_spec.is_a? InputSpec
-        raise ArgumentError.new("input_spec must be InputSpec object")
-      end
-      unless @rule_set.is_a? RuleSet
-        raise ArgumentError.new("rule_set must be RuleSet object")
-      end
-      unless @output_specs.first.is_a? OutputSpec
-        raise ArgumentError.new("default_output_spec must be OutputSpec object")
-      end
+    def initialize(input_spec, rule_set, output_spec, config_check = false)
+      validate_initialize_params(input_spec, rule_set, output_spec)
 
+      @input_spec = input_spec
+      @rule_set = rule_set
+      @output_specs = [output_spec]
+      @data_source_set = DataSourceSet.new
       Validator::Base.values = @input_spec
+      Validator::Base.data_source_set = @data_source_set
 
-      validate_configuration if configuration_check
+      validate_configuration if config_check
+    end
+
+    def validate_initialize_params(input_spec, rule_set, output_spec)
+      params =
+        [
+          [input_spec, InputSpec],
+          [rule_set, RuleSet],
+          [output_spec, OutputSpec]
+        ]
+
+      check_instances(params, ArgumentError)
     end
 
     def validate_configuration
-      # RuleSet
       @rule_set.validate_configuration
-      # OutputSpec
-      @output_specs.each do |spec|
-        spec.validate_configuration
-      end
+      @output_specs.each(&:validate_configuration)
     end
 
     def add_output_spec(output_spec, configuration_check = false)
-      unless output_spec.is_a? OutputSpec
-        raise ArgumentError.new("output_spec must be OutputSpec object")
-      end
+      check_instances([[output_spec, OutputSpec]], ArgumentError)
+
       @output_specs << output_spec
 
       validate_configuration if configuration_check
     end
 
+    def add_data_source(data_source)
+      @data_source_set << data_source
+    end
+
     def run(values)
       @input_spec.source = values
       @rule_set.check_all

data/lib/anodator/common.rb

@@ -0,0 +1,15 @@
+module Anodator
+  # Anodator common class.
+  #
+  # Common class is useful common functions.
+  module Common
+    def check_instances(value_and_classes, exception_class)
+      value_and_classes.each do |value_and_class|
+        v = value_and_class[0]
+        c = value_and_class[1]
+
+        raise exception_class, "#{v} must be #{c}" unless v.is_a? c
+      end
+    end
+  end
+end

data/lib/anodator/data_source.rb

@@ -0,0 +1,87 @@
+module Anodator
+  # Unknown key on DataSource error.
+  class UnknownKeyOnDataSourceError < StandardError; end
+  # DataSource is external data source for check input datas.
+  #
+  # datas = {
+  #   'key1' => {
+  #     name: 'taro',
+  #     age: 20
+  #   },
+  #   'key2' => {
+  #     name: 'jiro',
+  #     age: 35
+  #   }
+  # }
+  # # datas object must be respond to :[].
+  # ds = DataSource.new('name', datas)
+  class DataSource
+    VALID_OPTIONS = {
+      on_nil: %i[raise_error nil],
+      on_exception: %i[raise_error nil]
+    }.freeze
+
+    DEFAULT_OPTIONS = {
+      on_nil: :nil,
+      on_exception: :raise_error
+    }.freeze
+
+    attr_reader :identifier
+
+    def initialize(identifier, datas, options = {})
+      msg = 'datas must be respond to :[]'
+      raise ArgumentError, msg unless datas.respond_to?(:[])
+      options = merge_default_options(options)
+      validate_options(options)
+
+      @identifier = identifier.to_s
+      @datas = datas
+      @options = options
+    end
+
+    def [](key)
+      @datas[key].nil? ? on_nil_value : @datas[key]
+    rescue UnknownKeyOnDataSourceError
+      raise
+    rescue StandardError => e
+      on_exception(e)
+    end
+
+    private
+
+    def merge_default_options(options)
+      DEFAULT_OPTIONS.each_with_object(options.dup) do |(k, v), merged|
+        merged[k] ||= v
+      end
+    end
+
+    def validate_options(options)
+      validate_option_keys(options)
+      validate_option_values(options)
+    end
+
+    def validate_option_keys(options)
+      options.each_key do |key|
+        msg = "Invalid option '#{key.inspect}'"
+        raise ArgumentError, msg unless VALID_OPTIONS.key?(key)
+      end
+    end
+
+    def validate_option_values(options)
+      options.each do |key, value|
+        msg = "Invalid #{key.inspect} option value '#{value.inspect}'"
+        raise ArgumentError, msg unless VALID_OPTIONS[key].include?(value)
+      end
+    end
+
+    def on_nil_value
+      return nil if @options[:on_nil] == :nil
+      raise UnknownKeyOnDataSourceError, 'DataSource nil'
+    end
+
+    def on_exception(e)
+      return nil if @options[:on_exception] == :nil
+      raise UnknownKeyOnDataSourceError, e
+    end
+  end
+end

data/lib/anodator/data_source_set.rb

@@ -0,0 +1,36 @@
+require 'anodator/data_source'
+
+module Anodator
+  # duplicated DataSource Identifier error.
+  class DuplicatedDataSourceIdentifierError < StandardError; end
+  # DataSourceSet is a set of DataSource
+  class DataSourceSet
+    def initialize
+      @data_sources = {}
+    end
+
+    def <<(data_source)
+      msg = 'data_source must be DataSource.'
+      raise ArgumentError, msg unless data_source.is_a? DataSource
+
+      check_duplicate_key(data_source)
+    end
+
+    def fetch(identifier, key, column)
+      identifier = identifier.to_s.to_sym
+      key = key.to_s.to_sym
+      column = column.to_s.to_sym
+
+      @data_sources[identifier][key][column]
+    end
+
+    private
+
+    def check_duplicate_key(data_source)
+      key = data_source.identifier.to_sym
+      raise DuplicatedDataSourceIdentifierError if @data_sources.key?(key)
+
+      @data_sources[key] = data_source
+    end
+  end
+end

data/lib/anodator/input_spec.rb

@@ -1,60 +1,68 @@
-require "anodator/input_spec_item"
-require "anodator/anodator_error"
+require 'anodator/input_spec_item'
+require 'anodator/anodator_error'
 
 module Anodator
   class DuplicatedInputSpecItemError < AnodatorError; end
   class UnknownTargetExpressionError < AnodatorError; end
   class SourceDataNotProvidedError < AnodatorError; end
 
+  # InputSpec
   class InputSpec
     CALCULATION_HOLDER_REGEXP = /\[\[([^\]]+)\]\]/
 
+    include Common
+
     def initialize(spec_items = [])
       @spec_items  = []
       @source      = nil
-      @number_dict = { }
-      @name_dict   = { }
+      @number_dict = {}
+      @name_dict   = {}
+
+      check_instances([[spec_items, Array]], ArgumentError)
+      setup_input_spec_items(spec_items)
+    end
 
-      unless spec_items.is_a? Array
-        raise ArgumentError.new("initialized by Array by Hash(key is :name and :number")
+    def setup_input_spec_items(spec_items)
+      spec_items.each do |spec|
+        next unless %i[number name].all? { |k| spec.key?(k) }
+        push_spec_items(build_input_spec_item(spec))
       end
+    end
+    private :setup_input_spec_items
 
-      spec_items.each do |spec_item_values|
-        if spec_item_values.keys.include?(:number) &&
-            spec_item_values.keys.include?(:name)
-          if spec_item_values.keys.include?(:type) &&
-              !spec_item_values[:type].nil?
-            push_spec_items(InputSpecItem.new(spec_item_values[:number],
-                                              spec_item_values[:name],
-                                              spec_item_values[:type]))
-          else
-            push_spec_items(InputSpecItem.new(spec_item_values[:number],
-                                              spec_item_values[:name]))
-          end
-        end
+    def build_input_spec_item(spec)
+      if spec[:type].nil?
+        InputSpecItem.new(spec[:number], spec[:name])
+      else
+        InputSpecItem.new(spec[:number], spec[:name], spec[:type])
       end
     end
+    private :build_input_spec_item
 
     def push_spec_items(spec)
-      if @number_dict.keys.include?(spec.number)
-        raise DuplicatedInputSpecItemError.new("duplicated number spec item '#{spec.number}'")
-      end
-      if @name_dict.keys.include?(spec.name)
-        raise DuplicatedInputSpecItemError.new("duplicated name spec item '#{spec.name}'")
-      end
+      check_duplicate_key(spec.number, spec.name)
+
       @spec_items << spec
       index = @spec_items.size - 1
-      @number_dict[spec.number] = { :item => spec, :index => index }
-      @name_dict[spec.name]     = { :item => spec, :index => index }
+      @number_dict[spec.number] = { item: spec, index: index }
+      @name_dict[spec.name]     = { item: spec, index: index }
     end
     private :push_spec_items
 
+    def check_duplicate_key(num, name)
+      msg = nil
+      msg = "duplicated number spec item '#{num}'" if @number_dict.key?(num)
+      msg = "duplicated name spec item '#{name}'" if @name_dict.key?(name)
+
+      raise DuplicatedInputSpecItemError, msg unless msg.nil?
+    end
+    private :check_duplicate_key
+
     def source=(source)
-      if source.respond_to? :[]
-        @source = source
-      else
-        raise ArgumentError.new("source should respond to :[] method")
-      end
+      msg = 'source should respond to :[] method'
+      raise ArgumentError, msg unless source.respond_to? :[]
+
+      @source = source
     end
 
     def clear_source
@@ -62,104 +70,91 @@ module Anodator
     end
 
     def value_at(index)
-      raise SourceDataNotProvidedError.new if @source.nil?
+      raise SourceDataNotProvidedError if @source.nil?
+      msg = "accessed by index '#{index}'"
+      raise UnknownTargetExpressionError, msg if @spec_items[index].nil?
 
-      if @spec_items[index].nil?
-        raise UnknownTargetExpressionError.new("accessed by index '#{index}'")
-      else
-        return @source[index].to_s
-      end
+      @source[index].to_s
     end
 
     def value_at_by_number(number)
-      raise SourceDataNotProvidedError.new if @source.nil?
+      raise SourceDataNotProvidedError if @source.nil?
+      msg = "accessed by number '#{number}'"
+      raise UnknownTargetExpressionError, msg unless @number_dict.key?(number)
 
-      if @number_dict.keys.include?(number)
-        return value_at(@number_dict[number][:index])
-      else
-        raise UnknownTargetExpressionError.new("accessed by number '#{number}'")
-      end
+      value_at(@number_dict[number][:index])
     end
 
     def value_at_by_name(name)
-      raise SourceDataNotProvidedError.new if @source.nil?
+      raise SourceDataNotProvidedError if @source.nil?
+      msg = "accessed by name '#{name}'"
+      raise UnknownTargetExpressionError, msg unless @name_dict.key?(name)
 
-      if @name_dict.keys.include?(name)
-        return value_at(@name_dict[name][:index])
-      else
-        raise UnknownTargetExpressionError.new("accessed by name '#{name}'")
-      end
+      value_at(@name_dict[name][:index])
     end
 
     def value_by_calculation(calculation)
       holders = check_calculation_expression(calculation)
-
-      values = holders.inject({ }) do |hash, expression|
-        value = self[expression]
-        spec = spec_item_by_expression(expression)
-
-        case spec.type
-        when InputSpecItem::TYPE_NUMERIC
-          hash["[[#{expression}]]"] = %Q|BigDecimal("#{value}")|
-        else # String, other
-          hash["[[#{expression}]]"] = %Q|"#{value}"|
-        end
-        next hash
-      end
-
-      calculation.gsub!(CALCULATION_HOLDER_REGEXP) do |match|
-        values[match]
-      end
+      values = convert_values_from_holders(holders)
+      calculation.gsub!(CALCULATION_HOLDER_REGEXP) { |m| values[m] }
 
       value = eval(calculation)
-      value = value.to_s("F") if value.is_a? BigDecimal
+      value = value.to_s('F') if value.is_a? BigDecimal
 
       return value
-    rescue UnknownTargetExpressionError => ex
-      raise
-    rescue => ex
-      raise UnknownTargetExpressionError.new("accessed by calculation '#{calculation}'")
+    rescue StandardError
+      msg = "accessed by calculation '#{calculation}'"
+      raise UnknownTargetExpressionError, msg
     end
     private :value_by_calculation
 
+    def convert_values_from_holders(holders)
+      holders.each_with_object({}) do |expression, hash|
+        value = self[expression]
+        spec = spec_item_by_expression(expression)
+
+        hash["[[#{expression}]]"] =
+          if spec.type == InputSpecItem::TYPE_NUMERIC
+            %|BigDecimal("#{value}")|
+          else
+            %("#{value}")
+          end
+      end
+    end
+    private :convert_values_from_holders
+
     def [](target_expression)
-      raise SourceDataNotProvidedError.new if @source.nil?
+      raise SourceDataNotProvidedError if @source.nil?
+      return value_at(target_expression) if target_expression.is_a? Integer
 
-      if target_expression.is_a? Integer
-        return value_at(target_expression)
-      elsif /^CALC::(.+)$/.match target_expression
-        return value_by_calculation($1)
-      else
-        begin
-          return value_at_by_number(target_expression)
-        rescue UnknownTargetExpressionError
-          return value_at_by_name(target_expression)
-        end
+      if target_expression =~ /^CALC::(.+)$/
+        return value_by_calculation(Regexp.last_match(1))
       end
+
+      value_at_by_number(target_expression)
+    rescue UnknownTargetExpressionError
+      value_at_by_name(target_expression)
     end
 
     def spec_item_at(index)
-      if @spec_items[index].nil?
-        raise UnknownTargetExpressionError.new("accessed by index '#{index}'")
-      else
-        @spec_items[index].dup
-      end
+      msg = "accessed by index '#{index}'"
+      raise UnknownTargetExpressionError, msg if @spec_items[index].nil?
+
+      @spec_items[index].dup
     end
 
     def spec_item_at_by_number(number)
-      if @number_dict.keys.include?(number)
-        return @number_dict[number][:item].dup
-      else
-        raise UnknownTargetExpressionError.new("accessed by number '#{number}'")
-      end
+      msg = "accessed by number '#{number}'"
+      raise UnknownTargetExpressionError, msg unless @number_dict.key?(number)
+
+      @number_dict[number][:item].dup
     end
 
     def spec_item_at_by_name(name)
-      if @name_dict.keys.include?(name)
-        return @name_dict[name][:item].dup
-      else
-        raise UnknownTargetExpressionError.new("accessed by name '#{name}'")
-      end
+      msg = "accessed by name '#{name}'"
+      raise UnknownTargetExpressionError, msg unless @name_dict.key?(name)
+
+      @name_dict[name][:item].dup
     end
 
     def spec_items_by_calculation(calculation)
@@ -171,26 +166,25 @@ module Anodator
     private :spec_items_by_calculation
 
     def spec_item_by_expression(target_expression)
-      if target_expression.is_a? Integer
-        return spec_item_at(target_expression)
-      elsif /^CALC::(.+)$/.match target_expression
-        return spec_items_by_calculation($1)
-      else
-        begin
-          return spec_item_at_by_number(target_expression)
-        rescue UnknownTargetExpressionError
-          return spec_item_at_by_name(target_expression)
-        end
+      return spec_item_at(target_expression) if target_expression.is_a? Integer
+
+      if target_expression =~ /^CALC::(.+)$/
+        return spec_items_by_calculation(Regexp.last_match(1))
       end
+
+      return spec_item_at_by_number(target_expression)
+    rescue UnknownTargetExpressionError
+      return spec_item_at_by_name(target_expression)
     end
 
     # return all holders specs
     def check_calculation_expression(calculation)
-      if /(@|require|load|;)/.match calculation
-        return ArgumentError.new("Invalid calcuation expression '#{calcuation}'")
+      if calculation =~ /(@|require|load|;)/
+        raise ArgumentError, "Invalid calcuation expression '#{calcuation}'"
       end
 
-      calculation.scan(CALCULATION_HOLDER_REGEXP).flatten.map do |target_expression|
+      calculation.scan(CALCULATION_HOLDER_REGEXP)
+                 .flatten.map do |target_expression|
         spec_item_by_expression(target_expression)
         next target_expression
       end