trax_core 0.0.84 → 0.0.85

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc61a40b6e173df7ff14e66550fd7c5fa558ab4c
-  data.tar.gz: 9b5f6b14a3b4c714b094f8020b66f3d532a79855
+  metadata.gz: 607a79a7c4082da1e2a834475a6d4f9cdd0ae5e5
+  data.tar.gz: 77f3a354d9981ac41cdbbc16c5786f9788c62ab7
 SHA512:
-  metadata.gz: 18b3e5d1d9dc44a315bc88480c76b68ecb81a00d07dd41d14b831040ea3e62c7c696477ba9965c34f449a5f168aa35529f94ef3619f7ef2ebc99af8a5457bab7
-  data.tar.gz: 1013d42d2b1900af67bd2e46edf65c0e28a59c301c400ae60423d945acf7d06ae2656b260a95d5baec813671323b50adabcfefb4438fd40102be00f349e47a47
+  metadata.gz: 10c480758ec396d9175a51272457c24fbd8d1da41a354a93bce0163760e60add4d177213d83e8faf780e9f0cc76177912453f7472d424c664a4bde73bde83743
+  data.tar.gz: aa5dadf5ea48099d9b44b7da1f0b54bd2520e2c98b80b3eed7106da6b465f3f3d490dda21bb0c240f2d489459e6645b8421ea562a9f2044a224b3e1475f16a6d

data/.gitignore

@@ -8,6 +8,7 @@ InstalledFiles
 _yardoc
 coverage
 doc/
+vendor/
 lib/bundler/man
 pkg
 rdoc

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 script: bundle exec rspec
 rvm:
-  - 2.2
-  - 2.1
+  - 2.3.1
+  - 2.2.5
 notifications:
   email: false

data/lib/trax/core/definitions.rb

@@ -6,8 +6,8 @@ module Trax
       end
 
       def enum(klass_name, **options, &block)
-        attribute_klass = if options.key?(:extend)
-          _klass_prototype = options[:extend].constantize.clone
+        attribute_klass = if options.key?(:extends)
+          _klass_prototype = options[:extends].constantize.clone
           ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", _klass_prototype, :parent_definition => self, &block)
         else
           ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", ::Trax::Core::Types::Enum, :parent_definition => self, &block)
@@ -17,8 +17,8 @@ module Trax
       end
 
       def struct(klass_name, **options, &block)
-        attribute_klass = if options.key?(:extend)
-          _klass_prototype = options[:extend].constantize.clone
+        attribute_klass = if options.key?(:extends)
+          _klass_prototype = options[:extends].constantize.clone
           ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", _klass_prototype, :parent_definition => self, &block)
         else
           ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", ::Trax::Core::Types::Struct, :parent_definition => self, &block)

data/lib/trax/core/ext/hash.rb

@@ -1,21 +1,27 @@
-class Hash
+module HashExtensions
+  def assert_required_keys(*args)
+    missing_args = args.reject{|arg| self.key?(arg) }
+    raise ArgumentError.new("Missing keys: #{missing_args.join(', ')}") if missing_args.any?
+    self
+  end
+
   ## Returns selected keys, named or renamed as specified
   # myproduct = {:name => "something", :price => "20"}
-  # liability = myproduct.tap(&{:cost => :price})
+  # liability = myproduct.tap(&{:cost => :price}.to_transformer)
   # liability[:cost] == 20
   ## Note: Tap only works where source is a hash object, so use as otherwise
   # (because tap always returns the object you are tapping)
   # myproduct = ::OpenStruct.new({:name => "something", :price => "20"})
-  # liability.as!(&{:cost => :price})
+  # liability.as!({:cost => :price})
   # liability[:cost] == 20
   #
   # Transforming values:
   # Pass a hash as the value with the key being the source key/method
   # myproduct = ::OpenStruct.new({:name => "something", :price => "20"})
-  # my_sale_product = myproduct.as!(&{:sale_price => {:price => ->(val){ val / 2 } } })
+  # my_sale_product = myproduct.as!({:sale_price => {:price => ->(val){ val / 2 } } })
   # my_sale_product[:sale_price] == 10
 
-  def to_proc
+  def to_transformer
     ->(hash_or_object) {
       new_hash = {}
 
@@ -48,3 +54,7 @@ class Hash
     }
   end
 end
+
+class Hash
+  include HashExtensions
+end

data/lib/trax/core/ext/method.rb

@@ -0,0 +1,95 @@
+module MethodExtensions
+  # method(method_name).parameters returns an array of the parameters it accepts as well as the signature type
+  # :req = required, ordinal argument, i.e. def foo(one)
+  # :opt = optional ordinal argument, i.e. def foo(one=nil)
+  # :keyreq = required keyword argument i.e. def foo(req:)
+  # :key = optional keyword argument, i.e. def foo(one:nil)
+  # :rest = optional arguments splat, i.e. def foo(*args)
+  # :keyrest = optional keyword arguments splat, i.e. def foo(**args)
+
+  STRATEGIES_FOR_SEND_WHEN_METHOD = {
+    :accepts_nothing? => :strategy_for_method_without_arguments,
+    :accepts_arguments_and_keywords? => :strategy_for_method_with_arguments_and_keywords,
+    :accepts_arguments? => :strategy_for_method_with_arguments,
+    :accepts_keywords? => :strategy_for_method_with_keywords
+  }.freeze
+
+  def accepted_argument_signatures
+    @accepted_argument_signatures ||= self.parameters.any? ? self.parameters.map(&:first).uniq : []
+  end
+
+  def accepts_something?
+    @accepts_something ||= arity != 0
+  end
+
+  def accepts_nothing?
+    !accepts_something?
+  end
+
+  def accepts_arguments?
+    @accepts_arguments ||= requires_arguments? || accepts_optional_arguments? || accepts_arguments_splat?
+  end
+
+  def accepts_keywords?
+    @accepts_keywords ||= requires_keywords? || accepts_optional_keywords? || accepts_keywords_splat?
+  end
+
+  def accepts_arguments_and_keywords?
+    @accepts_arguments_and_keywords ||= accepts_arguments? && accepts_keywords?
+  end
+
+  def accepts_arguments_splat?
+    @accepts_arguments_splat ||= accepted_argument_signatures.include?(:rest)
+  end
+
+  def accepts_keywords_splat?
+    @accepts_keywords_splat ||= accepted_argument_signatures.include?(:keyrest)
+  end
+
+  def accepts_optional_arguments?
+    @accepts_optional_arguments ||= accepted_argument_signatures.include?(:opt)
+  end
+
+  def accepts_optional_keywords?
+    @accepts_optional_keywords ||= accepted_argument_signatures.include?(:key)
+  end
+
+  def execute_call_strategy(*args, **options)
+    __send__(strategy_for_call)
+  end
+
+  def requires_arguments?
+    @requires_arguments ||= accepted_argument_signatures.include?(:req)
+  end
+
+  def requires_keywords?
+    @requires_keywords ||= accepted_argument_signatures.include?(:keyreq)
+  end
+
+  def strategy_for_method_without_arguments(*args, **options)
+    call()
+  end
+
+  def strategy_for_method_with_keywords(*args, **options)
+    call(**options)
+  end
+
+  def strategy_for_method_with_arguments(*args, **options)
+    call(*args)
+  end
+
+  def strategy_for_method_with_arguments_and_keywords(*args, **options)
+    call(*args, **options)
+  end
+
+  def strategy_for_call
+    @strategy_for_call ||= begin
+      first_matching_question = STRATEGIES_FOR_SEND_WHEN_METHOD.keys.detect{ |k| send(k) }
+      STRATEGIES_FOR_SEND_WHEN_METHOD[first_matching_question]
+    end
+  end
+end
+
+class Method
+  include MethodExtensions
+end

data/lib/trax/core/ext/object.rb

@@ -1,7 +1,12 @@
 require "active_support/core_ext/object/try"
 class Object
-  def as!
-    yield self
+  def __smartsend__(method_name, *args, **options)
+    target = method(method_name)
+    target.execute_call_strategy(*args, **options)
+  end
+
+  def as!(h)
+    h.to_transformer.call(self)
   end
 
   # Defines a Configuration Class within a target module namespace, or nested class

data/lib/trax/core/fields.rb

@@ -38,6 +38,10 @@ module Trax
         @enums ||= by_type(:enum)
       end
 
+      def key?(k)
+        all.key?(k)
+      end
+
       def structs
         @structs ||= by_type(:struct)
       end

data/lib/trax/core/has_mixins.rb

@@ -21,7 +21,11 @@ module Trax
 
         mixin_module = base.const_set("Mixin", ::Module.new)
         mixin_module.module_attribute(:mixin_namespace) { base }
-        mixin_module.extend(::Trax::Core::Mixin)
+
+        # NOTE: This line causes specs to fail, because it loads before
+        # ::Trax::Core::Definitions. It's currently not being used by any other
+        # Trax gems, so we'll have to revisit this whenever they start using it
+        #mixin_module.extend(::Trax::Core::Mixin)
 
         mixin_module.module_eval do
           def self.extended(base)

data/lib/trax/core/transformer.rb

@@ -0,0 +1,244 @@
+module Trax
+  module Core
+    class Transformer < SimpleDelegator
+      attr_reader :input, :parent, :output
+
+      def self.inherited(subklass)
+        subklass.class_attribute :properties
+        subklass.properties = {}.with_indifferent_access
+        subklass.class_attribute :after_initialize_callbacks
+        subklass.after_initialize_callbacks = ::Set.new
+        subklass.class_attribute :after_transform_callbacks
+        subklass.after_transform_callbacks = ::Set.new
+      end
+
+      def self.after_initialize(&block)
+        after_initialize_callbacks << block
+      end
+
+      def self.after_transform(&block)
+        after_transform_callbacks << block
+      end
+
+      def self.properties_with_default_values
+        @properties_with_default_values ||= properties.values.select{ |prop| prop.try(:default) }
+      end
+
+      def self.nested_properties
+        @nested_properties ||= properties.values.select{|prop| prop.is_nested? }
+      end
+
+      def self.transformer_properties
+        @transformer_properties ||= properties.values.select{|prop| prop.ancestors.include?(::Trax::Core::Transformer) }
+      end
+
+      def self.transformer_properties_with_after_transform_callbacks
+        @transformer_properties_with_after_transform_callbacks ||= transformer_properties.select{|prop| prop.after_transform_callbacks.any? }
+      end
+
+      def self.is_nested?
+        !!self.try(:parent_definition)
+      end
+
+      def self.from_parent?
+        false
+      end
+
+      def self.property(_property_name, **options, &block)
+        options[:parent_definition] = self
+        options[:property_name] = _property_name
+        options[:with] = block if block_given?
+        transformer_klass_name = "#{name}::#{_property_name.camelize}"
+        transformer_klass = ::Trax::Core::NamedClass.new(transformer_klass_name, Property, **options)
+        self.properties[_property_name] = transformer_klass
+      end
+
+      def self.transformer(_property_name, **options, &block)
+        options[:parent_definition] = self
+        options[:property_name] = _property_name
+        options[:default] = ->(){ {}.with_indifferent_access } unless options.key?(:default)
+        options[:with] = block if block_given?
+        transformer_klass_name = "#{name}::#{_property_name.camelize}"
+        transformer_klass = ::Trax::Core::NamedClass.new(transformer_klass_name, Transformer, **options, &block)
+        self.properties[_property_name] = transformer_klass
+      end
+
+      def self.nested(*args, **options, &block)
+        transformer(*args, **options, &block)
+      end
+
+      def self.fetch_property_from_object(_property, obj)
+        if _property.include?('/')
+          property_chain = _property.split('/')
+          obj.dig(*property_chain)
+        else
+          obj[_property]
+        end
+      end
+
+      def initialize(obj={}, parent=nil)
+        @input = obj.dup
+        @output = {}.with_indifferent_access
+        @parent = parent if parent
+
+        initialize_output_properties
+        initialize_default_values
+        run_after_initialize_callbacks if run_after_initialize_callbacks?
+        run_after_transform_callbacks if run_after_transform_callbacks?
+      end
+
+      def [](_property)
+        if _property.include?('/')
+          property_chain = _property.split('/')
+          self.dig(*property_chain)
+        else
+          super(_property)
+        end
+      end
+
+      def key?(_property)
+        if _property.include?('/')
+          property_chain = _property.split('/')
+          !!self.dig(*property_chain)
+        else
+          super(_property)
+        end
+      end
+
+      def has_parent?
+        !!parent
+      end
+
+      def parent_key?(k)
+        return false unless has_parent?
+
+        parent.key?(k)
+      end
+
+      def __getobj__
+        @output
+      end
+
+      def to_hash
+        @to_hash ||= begin
+          duplicate_hash = self.__getobj__.dup
+
+          duplicate_hash.each_pair do |k, v|
+            if v.is_a?(::Trax::Core::Transformer)
+              duplicate_hash[k] = v.__getobj__
+            elsif v.is_a?(Property)
+              duplicate_hash[k] = v.__getobj__
+            end
+          end
+
+          duplicate_hash
+        end
+      end
+
+      def to_recursive_hash
+        @to_recursive_hash ||= begin
+          duplicate_hash = self.__getobj__.dup
+
+          self.each_pair do |k, v|
+            if v.is_a?(::Trax::Core::Transformer)
+              duplicate_hash[k] = v.to_hash
+            elsif v.is_a?(Property)
+              duplicate_hash[k] = v.__getobj__
+            end
+          end
+
+          duplicate_hash
+        end
+      end
+
+      private
+
+      def initialize_default_values
+        self.class.properties_with_default_values.each do |prop|
+          unless @output.key?(prop.property_name)
+            if prop.default.is_a?(Proc)
+              @output[prop.property_name] = prop.default.arity > 0 ? prop.default.call(@output) : prop.default.call
+            else
+              @output[prop.property_name] = prop.default
+            end
+          end
+        end
+      end
+
+      def initialize_output_properties
+        self.class.properties.each_pair do |k,property_klass|
+          if @input.key?(property_klass.property_name)
+            value = @input[property_klass.property_name]
+            @output[property_klass.property_name] = property_klass.new(value, self)
+          elsif @input.key?(property_klass.try(:from))
+            value = @input[property_klass.from]
+            @output[property_klass.property_name] = property_klass.new(value, self)
+          elsif property_klass.from_parent?
+            value = self.class.fetch_property_from_object(property_klass.from_parent, self.parent.input)
+            @output[property_klass.property_name] = property_klass.new(value, self)
+          elsif property_klass.ancestors.include?(::Trax::Core::Transformer)
+            value = if property_klass.default.is_a?(Proc)
+              property_klass.default.arity > 0 ? property_klass.default.call(self) : property_klass.default.call
+            else
+              property_klass.default
+            end
+
+            @output[property_klass.property_name] = property_klass.new(value, self)
+          end
+        end
+      end
+
+      #will not transform output based on callback result
+      def run_after_initialize_callbacks
+        self.class.after_initialize_callbacks.each do |callback|
+          @output.instance_eval(&callback)
+        end
+      end
+
+      def run_after_initialize_callbacks?
+        self.class.after_initialize_callbacks.any?
+      end
+
+      #will transform output with return of each callback
+      def run_after_transform_callbacks
+        self.class.after_transform_callbacks.each do |callback|
+          @output = self.instance_exec(@output, &callback)
+        end
+      end
+
+      def run_after_transform_callbacks?
+        self.class.after_transform_callbacks.any?
+      end
+    end
+
+    class Property < SimpleDelegator
+      def self.is_nested?
+        @is_nested ||= !!self.try(:parent_definition)
+      end
+
+      def self.is_translated?
+        @is_translated ||= !!self.try(:from)
+      end
+
+      def self.from_parent?
+        @from_parent ||= !!try(:from_parent)
+      end
+
+      def initialize(value, transformer)
+        @value = value
+
+        if self.class.try(:with)
+          @value = self.class.with.arity > 1 ? self.class.with.call(@value, transformer) : self.class.with.call(@value)
+        end
+      end
+
+      def nil?
+        __getobj__.nil?
+      end
+
+      def __getobj__
+        @value
+      end
+    end
+  end
+end

data/lib/trax/core/types/boolean.rb

@@ -9,6 +9,7 @@ module Trax
         def self.to_schema
           result = super
           result[:values] = [true, false]
+          result
         end
       end
     end

data/lib/trax/core/types/enum.rb

@@ -15,7 +15,7 @@ module Trax
         class_attribute :allow_nil, :raise_on_invalid
 
         ### Class Methods ###
-        def self.define_enum_value(const_name, val=nil, **attributes)
+        def self.define_enum_value(const_name, val=nil, **attributes, &block)
           name = "#{const_name}".underscore.to_sym
           const_name = name.to_s.camelize
           val = (self._values_hash.length + 1) if val.nil?
@@ -23,11 +23,8 @@ module Trax
           raise ::Trax::Core::Errors::DuplicateEnumValue.new(:klass => self.class.name, :value => const_name) if self === name
           raise ::Trax::Core::Errors::DuplicateEnumValue.new(:klass => self.class.name, :value => val) if self === val
 
-          value_klass = ::Trax::Core::NamedClass.new("#{self.name}::#{const_name}", ::Trax::Core::Types::EnumValue){
-            self.tag = name
-            self.value = val
-            self.attributes = attributes
-          }
+          value_klass_class_attributes = {:tag => name, :value => val, :attributes => attributes}
+          value_klass = ::Trax::Core::NamedClass.new("#{self.name}::#{const_name}", ::Trax::Core::Types::EnumValue, **value_klass_class_attributes, &block)
 
           self._values_hash[val] = value_klass
           self._names_hash[name] = value_klass
@@ -134,13 +131,15 @@ module Trax
         end
 
         def self.to_schema
-          ::Trax::Core::Definition.new(
+          result = ::Trax::Core::Definition.new(
             :name => self.name.demodulize.underscore,
             :source => self.name,
-            :type => :enum,
+            :type => self.type,
             :choices => choices.map(&:to_schema),
             :values => keys
           )
+          result[:default] = self.default if self.respond_to?(:default)
+          result
         end
 
         class << self

data/lib/trax/core/types/enum_value.rb

@@ -2,13 +2,6 @@ module Trax
   module Core
     module Types
       class EnumValue
-        def self.inherited(subclass)
-          super(subclass)
-          self.class_attribute(:tag)
-          self.class_attribute(:value)
-          self.class_attribute(:attributes)
-        end
-
         def self.as_json(options={})
           tag.to_s
         end
@@ -42,12 +35,13 @@ module Trax
             :source => self.name,
             :name => to_s,
             :type => :enum_value,
-            :integer_value => to_i
+            :integer_value => to_i,
+            :attributes => attributes
           )
         end
 
         def self.inspect
-          ":#{tag}"
+          tag ? ":#{tag}" : super
         end
 
         def self.include?(val)
@@ -60,7 +54,7 @@ module Trax
         end
 
         def self.===(val)
-          [tag, to_s, to_i].include?(val)
+          [::Trax::Core::Types::Enum, tag, to_s, to_i].include?(val)
         end
       end
     end

data/lib/trax/core/types/json.rb

@@ -5,6 +5,14 @@ module Trax
         def self.type
           :json
         end
+
+        def self.to_schema
+          ::Trax::Core::Definition.new(
+            :name => self.name.demodulize.underscore,
+            :source => self.name,
+            :type => self.type
+          )
+        end
       end
     end
   end

data/lib/trax/core/types/struct.rb

@@ -19,11 +19,11 @@ module Trax
           :array_of => [],
           :boolean  => nil,
           :enum     => nil,
-          :float    => 0.0,
+          :float    => nil,
           :integer  => nil,
           :json     => {},
           :set      => [],
-          :string   => "",
+          :string   => nil,
           :struct   => {},
           :time     => nil
         }.with_indifferent_access.freeze
@@ -134,10 +134,51 @@ module Trax
           alias :time :time_property
         end
 
+        def reverse_merge(other_hash)
+          self.class.new(other_hash).merge(self)
+        end
+
+        def reverse_merge!(other_hash)
+          self.class.new(other_hash).merge!(self)
+        end
+
+        def reverse_merge_present_values_only
+          other = other_hash.delete_if{|k,v| v.nil? || self.value_present_for_key?(k) }
+          other.keys.each_with_object(self) do |k, result|
+            self.delete(k) if !self.value_present_for_key?(k)
+          end
+
+          self.merge(other)
+        end
+
+        def reverse_merge_present_values_only!(other_hash)
+           other = other_hash.delete_if{|k,v| v.nil? || self.value_present_for_key?(k) }
+           other.keys.each_with_object(self) do |k, result|
+             self.delete(k) if !self.value_present_for_key?(k)
+           end
+
+           self.merge!(other)
+        end
+
         def value
           self
         end
 
+        def value_present_for_key?(k)
+          case self.class.fields_module.all[k].type
+          when :struct
+            !self.__send__(k).empty?
+          when :boolean
+            !self.__send__(k).nil?
+          when :array, :set
+            self.__send__(k) && self.__send__(k).length > 0
+          when :string
+            self.__send__(k).present?
+          else
+            !self.__send__(k).nil?
+          end
+        end
+
         private
 
         #By default, strings/int/bool wont get cast to value objects
@@ -146,8 +187,8 @@ module Trax
           name = name.is_a?(::Symbol) ? name.to_s : name
           klass_name = "#{fields_module.name.underscore}/#{property_name}".camelize
 
-          attribute_klass = if options.key?(:extend)
-            _klass_prototype = options[:extend].is_a?(::String) ? options[:extend].safe_constantize : options[:extend]
+          attribute_klass = if options.key?(:extends)
+            _klass_prototype = options[:extends].is_a?(::String) ? options[:extends].safe_constantize : options[:extends]
             _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => self, **options, &block)
             _klass
           else

data/lib/trax/core/types/value_object.rb

@@ -10,6 +10,10 @@ module Trax
           @value
         end
 
+        def nil?
+          @value.nil?
+        end
+
         def self.symbolic_name
           name.demodulize.underscore.to_sym
         end
@@ -19,11 +23,13 @@ module Trax
         end
 
         def self.to_schema
-          ::Trax::Core::Definition.new(
+          result = ::Trax::Core::Definition.new(
             :name => self.name.demodulize.underscore,
             :source => self.name,
             :type => self.type
           )
+          result[:default] = self.default if self.respond_to?(:default)
+          result
         end
       end
     end