trax_core 0.0.84 → 0.0.85

data/lib/trax/core.rb

@@ -4,6 +4,7 @@ require_relative './core/fs'
 require_relative './core/ext/array'
 require_relative './core/ext/class'
 require_relative './core/ext/enumerable'
+require_relative './core/ext/method'
 require_relative './core/ext/module'
 require_relative './core/ext/hash'
 require_relative './core/ext/object'
@@ -14,6 +15,17 @@ require_relative './core/ext/uri'
 require_relative './core/primitives/enum_value'
 require_relative './core/primitives/enum'
 
+if(::RUBY_VERSION < '2.3')
+  begin
+    require 'ruby_dig'
+  rescue LoadError => e
+    raise unless e.message =~ /ruby_dig/
+    error = e.exception("Trax::Core::Transformer relies on ruby_dig shim, add gem 'ruby_dig' to gemfile")
+    error.set_backtrace(e.backtrace)
+    raise error
+  end
+end
+
 module Trax
   module Core
     extend ::ActiveSupport::Autoload
@@ -37,6 +49,7 @@ module Trax
     autoload :NamedClass
     autoload :NamedModule
     autoload :SilenceWarnings
+    autoload :Transformer
     autoload :Types
     autoload :PathPermutations
   end

data/lib/trax_core/version.rb

@@ -1,3 +1,3 @@
 module TraxCore
-  VERSION = "0.0.84"
+  VERSION = "0.0.85"
 end

data/spec/support/defs.rb

@@ -8,6 +8,19 @@ module Defs
     define :accessories, 4
   end
 
+  struct :ShipmentAttributes do
+    string :tracking_number
+    float :weight
+    integer :insurance_amount
+    boolean :is_insured
+    array :notes
+    enum :shipping_type do
+      define :standard, 1
+      define :overnight, 2
+      define :same_day, 3
+    end
+  end
+
   struct :ProductAttributes do
     string :name, :default => ""
     float :price, :default => 9.99
@@ -16,7 +29,7 @@ module Defs
     array :categories, :of => "Defs::Category", :default => []
   end
 
-  struct :ShoesAttributes, :extend => "Defs::ProductAttributes" do
+  struct :ShoesAttributes, :extends => "Defs::ProductAttributes" do
     enum :size do
       define :mens_8,  1
       define :mens_9,  2
@@ -25,4 +38,19 @@ module Defs
       define :mens_12, 5
     end
   end
+
+  struct :ShirtAttributes, :extends => "Defs::ProductAttributes" do
+    string :name, :default => "Three-Fifty"
+    float :price, :default => 3.50
+    integer :quantity_in_stock, :default => 5
+    boolean :is_active, :default => true
+    array :categories, :of => "Defs::Category", :default => [:default, :clothing]
+    enum :size, :default => :womens_m do
+      define :womens_xs, 1
+      define :womens_s,  2
+      define :womens_m,  3
+      define :womens_l,  4
+      define :womens_xl, 5
+    end
+  end
 end

data/spec/support/storefront/product.rb

@@ -1,3 +1,5 @@
+require_relative "../fake_namespace"
+
 module Storefront
   class Product
     include ::FakeNamespace::Mixable

data/spec/trax/array_spec.rb

@@ -9,9 +9,7 @@ describe ::Array do
   end
 
   describe "#to_proc" do
-    it{
-      subject.map(&[:name, :price]).map(&:last).sum.should eq 90
-    }
+    it { expect(subject.map(&[:name, :price]).map(&:last).sum).to eq 90 }
 
     context "array of non hash objects" do
       subject {
@@ -21,9 +19,7 @@ describe ::Array do
         ]
       }
 
-      it {
-        subject.map(&[:name, :price]).map(&[:price]).sum.should eq 90
-      }
+      it { expect(subject.map(&[:name, :price]).map(&[:price]).sum).to eq 90 }
     end
   end
 end

data/spec/trax/core/definitions_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe ::Trax::Core::Definitions do
-  subject { ::Defs }
+  subject(:definitions) { ::Defs }
 
   context "fields" do
-    it { subject[:category].should eq subject::Category }
+    it { expect(subject[:category]).to eq subject::Category }
   end
 
   context "enum" do
@@ -42,4 +42,78 @@ describe ::Trax::Core::Definitions do
     it { expect(subject::ShoesAttributes.new).to have_key(:price) }
     it { expect(subject::ShoesAttributes.new(:size => :mens_8).size.to_i).to eq 1 }
   end
+
+  context "schema" do
+    let(:schema) { definitions.to_schema }
+
+    context "field defaults" do
+      context "with defaults" do
+        subject { schema[:shirt_attributes][:fields][field_name][:default] }
+
+        context "string" do
+          let(:field_name) { :name }
+          it { is_expected.to eq("Three-Fifty") }
+        end
+
+        context "float" do
+          let(:field_name) { :price }
+          it { is_expected.to eq(3.50) }
+        end
+
+        context "integer" do
+          let(:field_name) { :quantity_in_stock }
+          it { is_expected.to eq(5) }
+        end
+
+        context "boolean" do
+          let(:field_name) { :is_active }
+          it { is_expected.to eq(true) }
+        end
+
+        context "array" do
+          let(:field_name) { :categories }
+          it { is_expected.to eq([:default, :clothing]) }
+        end
+
+        context "enum" do
+          let(:field_name) { :size }
+          it { is_expected.to eq(:womens_m) }
+        end
+      end
+
+      context "without defaults" do
+        subject { schema[:shipment_attributes][:fields][field_name] }
+
+        context "string" do
+          let(:field_name) { :tracking_number }
+          it { is_expected.to_not have_key(:default) }
+        end
+
+        context "float" do
+          let(:field_name) { :weight }
+          it { is_expected.to_not have_key(:default) }
+        end
+
+        context "integer" do
+          let(:field_name) { :insurance_amount }
+          it { is_expected.to_not have_key(:default) }
+        end
+
+        context "boolean" do
+          let(:field_name) { :is_insured }
+          it { is_expected.to_not have_key(:default) }
+        end
+
+        context "array" do
+          let(:field_name) { :notes }
+          it { is_expected.to_not have_key(:default) }
+        end
+
+        context "enum" do
+          let(:field_name) { :shipping_type }
+          it { is_expected.to_not have_key(:default) }
+        end
+      end
+    end
+  end
 end

data/spec/trax/core/eager_autoload_namespace_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe ::Trax::Core::EagerAutoloadNamespace do
   subject { ::Ecom }
 
-  its('autoload_class_names.length') { should eq 2 }
-  its('autoload_file_paths.length') { should eq 2 }
-  its(:eager_autoload_filepath) { should include('ecom') }
-  its(:module_path) { should be_a(::Pathname) }
+  its('autoload_class_names.length') { is_expected.to eq 2 }
+  its('autoload_file_paths.length') { is_expected.to eq 2 }
+  its(:eager_autoload_filepath) { is_expected.to include('ecom') }
+  its(:module_path) { is_expected.to be_a(::Pathname) }
 end

data/spec/trax/core/errors_spec.rb

@@ -1,23 +1,18 @@
 require 'spec_helper'
 
 describe ::Trax::Core::Errors do
+  let(:error_attributes) do
+    {
+      :request_url => 'http://www.somewhere.com',
+      :request_id => 'asdasdsdad1231421'
+    }
+  end
+
   subject { ::Errors::SiteBrokenError }
 
-  it { expect{ subject.new }.to raise_error(ArgumentError) }
+  it { expect { subject.new }.to raise_error(ArgumentError) }
 
-  it do
-    expect do
-      raise subject.new(
-        :request_url => 'http://www.somewhere.com',
-        :request_id => 'asdasdsdad1231421'
-      )
-    end.to raise_error(subject)
-  end
+  it { expect { raise subject.new(error_attributes) }.to raise_error(subject) }
 
-  it do
-    subject.new(
-      :request_url => 'http://www.somewhere.com',
-      :request_id => 'asdasdsdad1231421'
-    ).to_s.should include('http://www.somewhere.com')
-  end
+  it { expect(subject.new(error_attributes).to_s).to include('http://www.somewhere.com') }
 end

data/spec/trax/core/ext/array_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Array do
   subject { ["one", "two", "three", "one", ["two"]]}
 
-  it { subject.flat_compact_uniq!.should eq ["one", "two", "three"] }
+  it { expect(subject.flat_compact_uniq!).to eq ["one", "two", "three"] }
   it "modifies array in place" do
     test_subject = subject.flat_compact_uniq!
-    test_subject.object_id.should eq subject.object_id
+    expect(test_subject.object_id).to eq subject.object_id
   end
 end

data/spec/trax/core/ext/class_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe ::Class do
   describe ".superclasses_until" do
-    it {
-      ::InheritanceChainNamespace::D.superclasses_until(::InheritanceChainNamespace::A).should eq [
+    it do
+      expect(::InheritanceChainNamespace::D.superclasses_until(::InheritanceChainNamespace::A)).to eq [
         ::InheritanceChainNamespace::B,
         ::InheritanceChainNamespace::C
       ]
-    }
+    end
   end
 end

data/spec/trax/core/ext/hash_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Hash do
+  subject { {:one => :two, :three => :four } }
+
+  describe "#assert_required_keys" do
+    it { expect { subject.assert_required_keys(:five) }.to raise_error(ArgumentError) }
+    it { expect { subject.assert_required_keys(:one) }.not_to raise_error }
+  end
+end

data/spec/trax/core/ext/method_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Method do
+  before(:all) do
+    class MyNewFakeClass < OpenStruct
+      def self.i_dont_accept_arguments
+        "one"
+      end
+
+      def self.i_accept_ordinal_arguments(one, two)
+        return [one, two]
+      end
+
+      def self.i_accept_optional_ordinal_arguments(one=nil, two=nil)
+        return [one, two]
+      end
+
+      def self.i_accept_splat_arguments(*args)
+        return args
+      end
+
+      def self.i_accept_keyword_arguments(three:nil, one:, two:)
+        return [one, two]
+      end
+
+      def self.i_accept_keyword_arguments_splat(**options)
+        return options
+      end
+    end
+  end
+
+  subject { MyNewFakeClass.method(target_method) }
+
+  let(:fake_args) { ['something'] }
+  let(:fake_params) { {:else => 'anything'} }
+
+  context "method knows what it accepts" do
+    describe '.i_dont_accept_arguments' do
+      let(:target_method) { 'i_dont_accept_arguments' }
+
+      it { expect(subject.accepts_arguments?).to eq false }
+      it { expect(subject.accepts_keywords?).to eq false }
+      it { expect(subject.accepts_arguments_splat?).to eq false }
+      it {
+        expect(subject).to receive(:strategy_for_method_without_arguments)
+        subject.execute_call_strategy(*fake_args, **fake_params)
+      }
+    end
+
+    describe '.i_accept_ordinal_arguments' do
+      let(:target_method) { 'i_accept_ordinal_arguments' }
+
+      it { expect(subject.accepts_arguments?).to eq true }
+      it { expect(subject.accepts_keywords?).to eq false }
+      it { expect(subject.accepts_arguments_splat?).to eq false }
+      it {
+        expect(subject).to receive(:strategy_for_method_with_arguments)
+        subject.execute_call_strategy(*fake_args, **fake_params)
+      }
+    end
+
+    describe '.i_accept_optional_ordinal_arguments' do
+      let(:target_method) { 'i_accept_optional_ordinal_arguments' }
+
+      it { expect(subject.accepts_arguments?).to eq true }
+      it { expect(subject.accepts_optional_arguments?).to eq true }
+      it { expect(subject.accepts_keywords?).to eq false }
+      it { expect(subject.accepts_arguments_splat?).to eq false }
+      it {
+        expect(subject).to receive(:strategy_for_method_with_arguments)
+        subject.execute_call_strategy(*fake_args, **fake_params)
+      }
+    end
+
+    describe '.i_accept_splat_arguments' do
+      let(:target_method) { 'i_accept_splat_arguments' }
+
+      it { expect(subject.accepts_arguments?).to eq true }
+      it { expect(subject.accepts_keywords?).to eq false }
+      it { expect(subject.accepts_arguments_splat?).to eq true }
+      it {
+        expect(subject).to receive(:strategy_for_method_with_arguments)
+        subject.execute_call_strategy(*fake_args, **fake_params)
+      }
+    end
+
+    describe '.i_accept_keyword_arguments' do
+      let(:target_method) { 'i_accept_keyword_arguments' }
+
+      it { expect(subject.accepts_arguments?).to eq false }
+      it { expect(subject.accepts_keywords?).to eq true }
+      it { expect(subject.accepts_arguments_splat?).to eq false }
+    end
+
+    describe '.i_accept_keyword_arguments_splat' do
+      let(:target_method) { 'i_accept_keyword_arguments_splat' }
+
+      it { expect(subject.accepts_arguments?).to eq false }
+      it { expect(subject.accepts_arguments_splat?).to eq false }
+      it { expect(subject.accepts_keywords?).to eq true }
+      it { expect(subject.accepts_keywords_splat?).to eq true }
+    end
+  end
+end

data/spec/trax/core/ext/module_spec.rb

@@ -10,7 +10,7 @@ describe ::Module do
       end
     end
 
-    it { Trax.some_fake_hash.should be_a(Hash) }
+    it { expect(Trax.some_fake_hash).to be_a(Hash) }
   end
 
   describe ".recursively_define_namespaced_class" do
@@ -27,7 +27,7 @@ describe ::Module do
         Trax.recursively_define_namespaced_class("Core::FakeKlass", Hash)
       end
 
-      it { Trax::Core::FakeKlass.superclass.should == Hash }
+      it { expect(Trax::Core::FakeKlass.superclass).to eq Hash }
     end
   end
 
@@ -42,14 +42,14 @@ describe ::Module do
 
     subject{ ::Trax::Core::FakeNamespace::Configuration }
 
-    its(:superclass) { should eq ::Trax::Core::Configuration }
+    its(:superclass) { is_expected.to eq ::Trax::Core::Configuration }
 
     it "sets up configuration options" do
       ::Trax::Core::FakeNamespace.configure do |config|
         config.something = 'anything'
       end
 
-      ::Trax::Core::FakeNamespace.config.something.should eq 'anything'
+      expect(::Trax::Core::FakeNamespace.config.something).to eq 'anything'
     end
   end
 
@@ -84,7 +84,7 @@ describe ::Module do
         config.base_url = 'somewhere'
       end
 
-      ::Trax::Core::YetAnotherFakeClass.config.allowed_ips[0].should eq '192.231.1234'
+      expect(::Trax::Core::YetAnotherFakeClass.config.allowed_ips[0]).to eq '192.231.1234'
     end
   end
 end

data/spec/trax/core/ext/object_spec.rb

@@ -12,22 +12,22 @@ describe ::Object do
 
   describe ".try_chain" do
     it "wraps multiple calls to try and calls try on return value" do
-      subject.try_chain(:name, :underscore).should eq "some_fake_class"
+      expect(subject.try_chain(:name, :underscore)).to eq "some_fake_class"
     end
 
     it "handles return if nil is in chain" do
-      subject.try_chain(:name, :somefakemethod).should be_nil
+      expect(subject.try_chain(:name, :somefakemethod)).to be_nil
     end
 
     it "handles instances of class" do
-      SomeFakeClass.new.try_chain(:class, :name, :underscore).should eq "some_fake_class"
+      expect(SomeFakeClass.new.try_chain(:class, :name, :underscore)).to eq "some_fake_class"
     end
   end
 
   describe ".set_fully_qualified_constant" do
     it "sets a fully qualified constant" do
       result = Object.set_fully_qualified_constant("SomeFakeClass::SomeFakeNestedClass", Class.new)
-      result.name.should eq "SomeFakeClass::SomeFakeNestedClass"
+      expect(result.name).to eq "SomeFakeClass::SomeFakeNestedClass"
     end
 
     it "raises error if no valid namespace to set constant upon is passed" do
@@ -40,7 +40,7 @@ describe ::Object do
       obj = SomeFakeClass.new
       obj.instance_variable_set(:@someivar, "anything")
       obj.reset_instance_variables(:someivar)
-      obj.instance_variable_get(:@someivar).should be nil
+      expect(obj.instance_variable_get(:@someivar)).to be nil
     end
   end
 end

data/spec/trax/core/transformer_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe ::Trax::Core::Transformer do
+  let(:payload) do
+    {
+      "name" => "Uber",
+      "legalName" => "Uber, Inc.",
+      "url" => "http =>//uber.com",
+      "metrics" => {
+        "raised" => 1502450000,
+        "annualRevenue" => 20000
+      },
+      "somethingElse" => "somethingElseValue",
+      "some_value_transform" => 10,
+      "some_value_to_times_by" => 2,
+      "some_value" => 30,
+      "stats" => {
+        "number_of_widgets" => 20,
+        "number_of_employees" => 40
+      },
+      "some_object" => {
+        "thing" => 1
+      },
+      "some_other_object" => {
+        "some_value" => 2
+      },
+      "some_unmapped_var" => 2
+    }.with_indifferent_access
+  end
+
+  before do
+    class PayloadTransformer < ::Trax::Core::Transformer
+      property "name"
+      property "something", :default => ->(v) { "anything" }
+      property "some_non_proc_default", :default => 5
+      property "legal_name", :from => "legalName"
+
+      property "some_value"
+      property "some_value_to_times_by"
+      property "some_value_transform", :default => ->(i){ 1 } do |value, instance|
+        value * instance["some_value_to_times_by"]
+      end
+
+      transformer "stats" do
+        property "number_of_employees"
+        property "raised", :from_parent => "metrics/raised"
+        property "google_rank", :from_parent => "metrics/googleRank"
+      end
+
+      transformer "website" do
+        property "url", :from_parent => "url"
+      end
+
+      transformer "some_object" do
+        property "thing"
+
+        after_transform do
+          OpenStruct.new(self)
+        end
+      end
+
+      transformer "some_other_object" do
+        property "some_value"
+
+        after_transform do |result|
+          self['result'] = result['some_value'] * self.parent.input["some_unmapped_var"]
+          OpenStruct.new(self)
+        end
+      end
+    end
+  end
+
+  subject {
+    PayloadTransformer.new(payload)
+  }
+
+  context "class methods" do
+    describe ".transformer" do
+      it {
+        expect(subject.class.properties['stats'].is_nested?).to eq true
+      }
+    end
+  end
+
+  context "property mapping strategies" do
+    it "property declration without options" do
+      expect(subject["name"]).to eq "Uber"
+    end
+
+    context "property with default value" do
+      it "value is a proc" do
+        expect(subject["something"]).to eq "anything"
+      end
+
+      it "value is not a proc" do
+        expect(subject["some_non_proc_default"]).to eq 5
+      end
+    end
+
+    context "property key translated" do
+      it {
+        expect(subject["legal_name"]).to eq "Uber, Inc."
+      }
+
+      it "removes translated value from hash" do
+        expect(subject.to_hash).to_not have_key("legalName")
+      end
+    end
+
+    context "nested properties" do
+      it "mapping from source hash" do
+        expect(subject["stats"]["number_of_employees"]).to eq 40
+      end
+
+      it "mapping from parent nested property" do
+        expect(subject["stats"]["raised"]).to eq payload["metrics"]["raised"]
+      end
+
+      it "brand new nested property" do
+        expect(subject["website"]["url"]).to eq payload["url"]
+      end
+    end
+
+    context "callbacks" do
+      context "after transform" do
+        it "runs after transform callbacks which can mutate return result" do
+          expect(subject["some_object"].thing).to eq 1
+        end
+
+        it "passes instance" do
+          expect(subject["some_other_object"].result).to eq 4
+        end
+      end
+
+      context "after transform" do
+        it "runs after transform callbacks which can mutate return result" do
+          expect(subject["some_object"].thing).to eq 1
+        end
+
+        it "wraps return value in class" do
+          expect(subject["some_object"].__getobj__.is_a?(::OpenStruct)).to eq true
+        end
+      end
+    end
+
+    context "to_hash" do
+      it "unwraps nested transformers" do
+        expect(subject.to_hash["some_object"].is_a?(::OpenStruct)).to eq true
+      end
+    end
+
+    context "to_recursive_hash" do
+      it "unwraps nested transformers" do
+        expect(subject.to_recursive_hash["some_object"].is_a?(::OpenStruct)).to eq true
+      end
+    end
+
+    it {
+      expect(subject["some_value"]).to eq 30
+    }
+
+    it {
+      expect(subject["some_value_to_times_by"]).to eq 2
+    }
+
+    it {
+      expect(subject["some_value_transform"]).to eq 20
+    }
+  end
+end

data/spec/trax/core/types/array_spec.rb

@@ -15,8 +15,8 @@ describe ::Trax::Core::Types::Array do
 
   context ".of" do
     let(:test_subject) { subject.new({:width => 1}) }
-    it { test_subject[0].width.should eq 1 }
-    it { test_subject[0].height.should eq 0 }
+    it { expect(test_subject[0].width).to eq 1 }
+    it { expect(test_subject[0].height).to eq 0 }
 
     context "does not duplicate values" do
       it {
@@ -35,7 +35,7 @@ describe ::Trax::Core::Types::Array do
   context "ArrayOf" do
     subject { ::Trax::Core::Types::ArrayOf[::AnotherFakeStructNamespace::Widget] }
     let(:test_subject) { subject.new({:width => 1}) }
-    it { test_subject[0].width.should eq 1 }
-    it { test_subject[0].height.should eq 0 }
+    it { expect(test_subject[0].width).to eq 1 }
+    it { expect(test_subject[0].height).to eq 0 }
   end
 end