trax_core 0.0.71 → 0.0.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00148fce6abf94b4bae0f495890d58d637c7ef7c
-  data.tar.gz: 6b997761c5627bef815cadab245859c82b08e1d1
+  metadata.gz: c6d1154c6a3219971c25e70ac2c4a820f313740d
+  data.tar.gz: ba70a2bd38733dc7c401d4750e1ce4f86313df9c
 SHA512:
-  metadata.gz: 5135d5b5f0937409b9149c47c9b38fc813192d7b0bd3637a10181ceea66aabc5f833ed60bad04aec99c380265dc0462d58eed83d177b9a67910d4fd0656aa234
-  data.tar.gz: fd4d5910f334c643e5b1120098f1d601dab9a1facd9473359f1211df0dbeda18ffee17ac95408c91f3b3e753f187f0d8ba204010873fd7d62df382d80dc6fc49
+  metadata.gz: 9c3ef17bf573140d83ab0d9f7f67de7d3d6c70174f28fca5db8c38cfb2fa19f7fc06c0be3165499e55820773360dd2769e75313c758c9e121aed3cb3067ef2a2
+  data.tar.gz: df4bb2354da8d72a729e951193dbe2d640c8d4b6c6b6a8ebd4e446025d726858e68a0802aa2325a425795125d0bf2c2e4e5026467df66c1473a1cdbaebb49cb8

data/lib/trax/core/concern.rb

@@ -1,47 +1,49 @@
 module Trax
   module Core
     module Concern
-      def included(base = nil, &block)
-        super(base, &block)
+      def self.extended(base)
+        base.extend(::ActiveSupport::Concern)
 
         trace = ::TracePoint.new(:end) do |tracepoint|
-          if tracepoint.self == base
-            trace.disable
-
-            if self.instance_variable_defined?(:@_after_included_block)
-              base.instance_eval(&self.instance_variable_get(:@_after_included_block))
+          if tracepoint.self.singleton_class.included_modules.first == base
+            if base.instance_variable_defined?(:@_after_extended_block)
+              tracepoint.self.module_exec(base, &base.instance_variable_get(:@_after_extended_block))
             end
+
+            trace.disable
           end
         end
 
         trace.enable
-      end
 
-      def self.extended(base)
-        base.extend(::ActiveSupport::Concern)
+        base
+      end
 
-        super(base)
+      def included(base = nil, &block)
+        super(base, &block) if defined?(super)
 
         trace = ::TracePoint.new(:end) do |tracepoint|
           if tracepoint.self == base
-            trace.disable
-
-            if base.instance_variable_defined?(:@_after_extended_block)
-              base.instance_variable_get(:@_after_extended_block).call
+            if self.instance_variable_defined?(:@_after_included_block)
+              base.instance_eval(&self.instance_variable_get(:@_after_included_block))
             end
+
+            trace.disable
           end
         end
 
         trace.enable
-      end
 
-      def after_extended(&block)
-        self.instance_variable_set(:@_after_extended_block, block)
+        base
       end
 
       def after_included(&block)
         self.instance_variable_set(:@_after_included_block, block)
       end
+
+      def after_extended(&block)
+        self.instance_variable_set(:@_after_extended_block, block)
+      end
     end
   end
 end

data/lib/trax/core/configuration.rb

@@ -9,52 +9,92 @@ module Trax
 
       class_attribute :source
 
-      def initialize
-        set_default_values
-
-        yield self if block_given?
-
-        raise_errors unless self.valid?
-      end
-
-      def set_default_values
-        self.class.configurable_options.select{|attr_name, hash| hash.key?(:default) }.each_pair do |attr_name,hash|
-          __send__("#{attr_name}=", hash[:default])
-        end
+      def self.after_configured(&block)
+        self.instance_variable_set("@_after_configured_block", block)
       end
 
       def self.inherited(subklass)
         super(subklass)
 
+        subklass.class_attribute :options_module
+        subklass.options_module = subklass.const_set("Options", ::Module.new)
+        subklass.include(subklass.options_module)
+
         subklass.class_attribute :configurable_options
         subklass.configurable_options = {}
       end
 
+      #the reason for defining the methods in the options module which gets
+      #dynamically created is to preserve the inheritance chain
+      #so def something= can be overwritten, and call super, an example is in
+      #Trax::Model::UniqueId
+      #there probably is a cleaner way to do it though.
       def self.option(attr_name, options = {})
-        attr_accessor attr_name
-
         validates_presence_of(attr_name) if(options.key?(:required))
-
         if(options.key?(:validates))
           validates(attr_name, options[:validates])
         end
 
-        define_method("#{attr_name}=") do |val|
-          value = options.key?(:setter) ? options[:setter].call(val) : val
-          instance_variable_set("@#{attr_name}", value)
+        options_module.module_eval do
+          attr_reader(attr_name)
 
-          raise_errors unless self.valid?
-        end
+          define_method(:"#{attr_name}=") do |val|
+            value = options.key?(:setter) ? options[:setter].call(val) : val
+            instance_variable_set("@#{attr_name}", value)
+
+            raise_errors unless self.valid?
+          end
 
-        if(options.key?(:getter))
-          define_method(attr_name) do |val|
-            options[:getter].call(val)
+          if(options.key?(:getter))
+            define_method(attr_name) do |val|
+              options[:getter].call(val)
+            end
           end
         end
 
         self.configurable_options[attr_name] = options
       end
 
+      def self.klass(&block)
+        #so we can properly resolve super lookups, we define new module and include
+        mod = ::Module.new
+        mod.module_eval(&block)
+        include(mod)
+      end
+
+      def initialize
+        set_default_values
+
+        yield self if block_given?
+
+        raise_errors unless self.valid?
+
+        self.class.instance_variable_get("@_after_configured_block").call(self) if self.class.instance_variable_defined?("@_after_configured_block")
+      end
+
+      def compact
+        cached_hash.compact
+      end
+
+      def cached_hash
+        @cached_hash ||= hash
+      end
+
+      def hash
+        configurable_options.keys.each_with_object({}) do |key, result|
+          result[key] =  __send__(key)
+        end
+      end
+
+      def set_default_values
+        self.class.configurable_options.select{|attr_name, hash| hash.key?(:default) }.each_pair do |attr_name, hash|
+          parent_context = self.class.parent_name.try(:constantize) if self.class.try(:parent_name)
+
+          default_value_for_option = hash[:default].is_a?(Proc) ? self.instance_exec(parent_context, &hash[:default]) : hash[:default]
+          __send__("#{attr_name}=", default_value_for_option)
+        end
+      end
+
       def merge!(options = {})
         options.each_pair{ |k,v| __send__("#{k}=", v) }
       end

data/lib/trax/core/definition.rb

@@ -0,0 +1,6 @@
+module Trax
+  module Core
+    class Definition < ::Hashie::Mash
+    end
+  end
+end

data/lib/trax/core/eager_autoload_namespace.rb

@@ -6,16 +6,8 @@ module Trax
         source_file_path = caller[0].partition(":")[0]
 
         base.module_eval do
-          extend ::ActiveSupport::Autoload
-
           @eager_autoload_filepath = source_file_path
         end
-
-        base.autoload_class_names.each do |klass|
-          base.autoload :"#{klass}"
-        end
-
-        base.eager_load!
       end
 
       def all

data/lib/trax/core/errors.rb

@@ -72,7 +72,7 @@ module Trax
 
         attr_reader :arguments_instance
 
-        def initialize(_attributes = {})
+        def initialize(**_attributes)
           @arguments_instance = self.class.permitted_arguments_klass.new(_attributes)
 
           super(message)
@@ -103,6 +103,22 @@ module Trax
           "registry. Registered mixins were #{mixin_namespace.mixin_registry.keys.join(', ')} \n"
         }
       end
+
+      class DuplicateEnumValue < ::Trax::Core::Errors::Base
+        argument :value
+        argument :klass
+        message {
+          "#{klass} duplicate value #{value}"
+        }
+      end
+
+      class InvalidEnumValue < ::Trax::Core::Errors::Base
+        argument :field
+        argument :value
+        message {
+          "#{field} Invalid enum value for #{value} "
+        }
+      end
     end
   end
 end

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

@@ -0,0 +1,26 @@
+class Array
+  #inspired by: http://thepugautomatic.com/2014/11/array-to-proc-for-hash-access/
+  def to_proc
+    ->(hash_or_object) {
+      if hash_or_object.is_a?(::Hash)
+        length == 1 ? hash_or_object[first] : hash_or_object.values_at(*self)
+      else
+        length == 1 ? hash_or_object.__send__(first) : self.each_with_object({}){ |method_name,result|
+                                                         result[method_name] = hash_or_object.__send__(method_name)
+                                                       }
+      end
+    }
+  end
+
+  def flat_compact_uniq!
+    self.flatten!
+    self.compact!
+    self.uniq!
+    self
+  end
+  alias :flatten_compact_uniq! :flat_compact_uniq!
+
+  def to_single_quoted_list
+    "\'#{self.join("', '")}\'"
+  end
+end

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

@@ -0,0 +1,10 @@
+class Class
+  def superclasses_until(klass, bottom_klass=self, superclass_chain = [])
+    if bottom_klass.superclass != klass
+      superclass_chain.unshift(bottom_klass.superclass)
+      return superclasses_until(klass, bottom_klass.superclass, superclass_chain)
+    else
+      return superclass_chain
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+class Hash
+  ## Returns selected keys, named or renamed as specified
+  # myproduct = {:name => "something", :price => "20"}
+  # liability = myproduct.tap(&{:cost => :price})
+  # 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[: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[:sale_price] == 10
+
+  def to_proc
+    ->(hash_or_object) {
+      new_hash = {}
+
+      if hash_or_object.is_a?(::Hash)
+        self.each_pair do |k,v|
+          if v.is_a?(Hash)
+            new_hash[k] = v.values.first.call(hash_or_object[v.keys.first])
+          elsif v.is_a?(Proc)
+            new_hash[k] = v.call(hash_or_object[k])
+          else
+            new_hash[k] = hash_or_object[v]
+          end
+        end
+
+        hash_or_object.keys.map{ |k| hash_or_object.delete(k) }
+        hash_or_object.merge!(new_hash)
+      else
+        self.each_pair do |k,v|
+          if v.is_a?(Hash)
+            new_hash[k] = v.values.first.call(hash_or_object.__send__(v.keys.first))
+          elsif v.is_a?(Proc)
+            new_hash[k] = v.call(hash_or_object.__send__(k))
+          else
+            new_hash[k] = hash_or_object.__send__(v)
+          end
+        end
+      end
+
+      return new_hash
+    }
+  end
+end

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

@@ -0,0 +1,21 @@
+class Is
+  def self.truthy?(val)
+    [true, false].include?(val)
+  end
+
+  def self.numeric?(val)
+    val.is_a?(::Numeric)
+  end
+
+  def self.string?(val)
+    val.is_a?(::String)
+  end
+
+  def self.symbol?(val)
+    val.is_a?(::Symbol)
+  end
+
+  def self.symbolic?(val)
+    val.is_a?(::String) || val.is_a?(::Symbol)
+  end
+end

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

@@ -1,6 +1,10 @@
 require "active_support/core_ext/object/try"
-require 'pry'
+
 class Object
+  def as!
+    yield self
+  end
+
   # Defines a Configuration Class within a target module namespace, or nested class
   # i.e. configuration_for(::Ecommerce::Cart) will define
   # Ecommerce::Cart::Configuration class, inherited form Trax::Core::Configuration
@@ -45,8 +49,10 @@ class Object
 
   def remove_instance_variables(*args)
     args.map{ |ivar_name|
-      remove_instance_variable(:"@#{ivar_name}") if instance_variable_defined?(:"@#{ivar_name}")
+      ivar_name = ivar_name.ivar? ? ivar_name : :"@#{ivar_name}"
+      remove_instance_variable(ivar_name) if instance_variable_defined?(ivar_name)
     }
+
     self
   end
   alias_method :reset_instance_variables, :remove_instance_variables

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

@@ -1,4 +1,8 @@
 class String
+  def symbolize
+    self.try_chain(:demodulize, :underscore, :to_sym)
+  end
+
   def translate(*args)
     I18n.translate(self.underscore, *args)
   end

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

@@ -0,0 +1,6 @@
+class Symbol
+  def is_ivar?
+    id2name.starts_with?("@")
+  end
+  alias :ivar? :is_ivar?
+end

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

@@ -0,0 +1,9 @@
+module URIExtensions
+  def join(*args)
+    self + args.map{ |arg| arg.is_a?(::String) ? arg : arg.to_s }.join("/")
+  end
+end
+
+class URI::Generic
+  include URIExtensions
+end

data/lib/trax/core/inheritance_hooks.rb

@@ -0,0 +1,56 @@
+module Trax
+  module Core
+    module InheritanceHooks
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def inherited(subklass)
+          super(subklass)
+
+          if self.instance_variable_defined?(:@_on_inherited_block)
+            subklass.instance_eval(&self.instance_variable_get(:@_on_inherited_block))
+          end
+
+          if subklass.class == Class
+            #this supports anonymous classes created with a block passed, i.e.
+            # Class.new(Enum, &Proc.new{VAL=1})
+            # otherwise Class.new wont be caught by tracepoint statement below
+            trace = ::TracePoint.new(:b_return) do |tracepoint|
+              if tracepoint.self.class == Class
+                if self.instance_variable_defined?(:@_after_inherited_block)
+                  subklass.instance_eval(&self.instance_variable_get(:@_after_inherited_block))
+                end
+
+                trace.disable
+              end
+            end
+
+            trace.enable
+          else
+            trace = ::TracePoint.new(:end) do |tracepoint|
+              if tracepoint.self == subklass
+                if self.instance_variable_defined?(:@_after_inherited_block)
+                  subklass.instance_eval(&self.instance_variable_get(:@_after_inherited_block))
+                end
+
+                trace.disable
+              end
+            end
+
+            trace.enable
+
+            self
+          end
+        end
+
+        def after_inherited(&block)
+          self.instance_variable_set(:@_after_inherited_block, block)
+        end
+
+        def on_inherited(&block)
+          self.instance_variable_set(:@_on_inherited_block, block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# require 'trax/core/inheritance_hooks'
+# require 'active_model/attribute_methods'
+### Examples
+# ProductCategory < Enum
+#   CLOTHING = 1
+#   SHOES = 2
+#   ACCESSORIES = 3
+# end
+# ProductCategory.keys => [:clothing, :shoes, :accessories]
+
+# StoreYearlyRevenue < Enum
+#   :'0_100000' = 1
+#   :'100000_999999' = 2
+#   :'1000000_99999999' = 3
+# end
+
+### Accepts either an integer or the name when setting a value
+# ProductCategory.new(1) => #{name: :clothing, :value => 1}
+
+class Enum < SimpleDelegator
+  class_attribute :allow_nil, :raise_on_invalid
+
+  ### Class Methods ###
+  def self.define_enum_value(const_name, val=nil)
+    name = "#{const_name}".underscore.to_sym
+    const_name = name.to_s.camelize
+    val = (self._values_hash.length + 1) if val.nil?
+
+    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 = self.const_set(const_name, Class.new(::EnumValue){
+      self.tag = name
+      self.value = val
+    })
+
+    self._values_hash[val] = value_klass
+    self._names_hash[name] = value_klass
+  end
+
+  def self.[](val)
+    if ::Is.numeric?(val)
+      self._values_hash[val]
+    elsif ::Is.symbolic?(val)
+      val = val.to_sym if val.is_a?(String)
+      self._names_hash[val]
+    elsif val.superclass.name == "EnumValue"
+      val = val.to_sym
+      self._names_hash[val]
+    end
+  end
+
+  def self.as_json(options={})
+    choice.to_s
+  end
+
+  def self.choices
+    @choices ||= self._values_hash.values
+  end
+
+  def self.formatted_choices
+    @formatted_choices ||= choices.each_with_object({}) do |choice, hash|
+      hash[choice.to_i] = choice.to_s
+    end
+  end
+
+  def self.select_values(*args)
+    args.flat_compact_uniq!
+    args.map{|arg| self[arg].to_i }
+  end
+
+  def self.define(*args)
+    define_enum_value(*args)
+  end
+
+  #define multiple values if its iterable
+  def self.define_values(*args)
+    args.each_with_index do |arg, i|
+      define_enum_value(arg, (i + 1))
+    end
+  end
+
+  def self.each(&block)
+    keys.each(&block)
+  end
+
+  def self.each_pair(&block)
+    self._names_hash.each_pair(&block)
+  end
+
+  def self.keys
+    _names_hash.keys
+  end
+
+  def self.key?(name)
+    _names_hash.key?(name)
+  end
+
+  def self.names
+    _names_hash.values
+  end
+
+  def self.no_raise_mode?
+    !raise_on_invalid
+  end
+
+  def self.valid_name?(val)
+    _names_as_strings.include?(val)
+  end
+
+  def self.valid_value?(val)
+    values.include?(val)
+  end
+
+  #because calling valid_value? in the define_enum_value method is unclear
+  def self.value?(val)
+    valid_value?(val)
+  end
+
+  def self.values
+    _names_hash.values.map(&:to_i)
+  end
+
+  def self.===(val)
+    _names_hash.values.any?{|v| v === val }
+  end
+
+  def self.type
+    :enum
+  end
+
+  def self.to_schema
+    ::Trax::Core::Definition.new(
+      :name => self.name.demodulize.underscore,
+      :source => self.name,
+      :type => :enum,
+      :choices => choices.map(&:to_schema),
+      :values => keys
+    )
+  end
+
+  class << self
+    alias :enum_value :define_enum_value
+    alias :define :define_enum_value
+    attr_accessor :_values_hash
+    attr_accessor :_names_hash
+    attr_accessor :_names_as_strings
+  end
+
+  ### Hooks ###
+  def self.inherited(subklass)
+    subklass.instance_variable_set(:@_values_hash, ::Hash.new)
+    subklass.instance_variable_set(:@_names_hash, ::Hash.new)
+    subklass.allow_nil = false
+    subklass.raise_on_invalid = false
+  end
+
+  ### Instance Methods ###
+  attr_reader :choice
+
+  def initialize(val)
+    self.choice = val unless val.nil? && self.class.allow_nil
+  end
+
+  def current_index
+    self.class.names.index(choice)
+  end
+
+  def choice=(val)
+    @choice = valid_choice?(val) ? self.class[val] : nil
+
+    raise ::Trax::Core::Errors::InvalidEnumValue.new(
+      :field => self.class.name,
+      :value => val
+    ) if self.class.raise_on_invalid && !@choice
+
+    @choice
+  end
+
+  def __getobj__
+    @choice || nil
+  end
+
+  def next_value
+    return choice if self.class.names.length == current_index
+    self.class.names[(current_index + 1)]
+  end
+
+  def next_value?
+    !(current_index == (self.class.names.length - 1))
+  end
+
+  #set choice if next value exists, return selected choi
+  def select_next_value
+    self.choice = next_value.to_sym if next_value?
+    self
+  end
+
+  def select_previous_value
+    self.choice = previous_value.to_sym if previous_value?
+    self
+  end
+
+  def previous_value
+    self.class.names[(current_index - 1)]
+  end
+
+  def previous_value?
+    !!current_index
+  end
+
+  def to_s
+    choice.to_s
+  end
+
+  def valid_choice?(val)
+    self.class === val
+  end
+end