dynamic_attribute_declaration 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b76e3142d2eed5bc086805161e9bc55595999f3
-  data.tar.gz: da66b9d1a260a72a7ef735d1eb8453334a1df032
+  metadata.gz: a98ea1bafab32de11aa18aa7e7cd6eaa5f797a1c
+  data.tar.gz: 8f3e53ed329c029bb37ee7da35c0223f18cd401d
 SHA512:
-  metadata.gz: 7be553e1972b3c823bc46e808f70474d88cddf96d86a421842577c0d47634db2307202ecdc6e3e0cfff0ef1003d183647abd660c6bd9d54e91c1b6b63db44c6d
-  data.tar.gz: 1c61921ef47b63b42135b87be4f54eb1d88cb30d1ac79f980df6812edb0470124723a5590610d04dc212e90f70ae62fdaade207b61a7d2a751574e9ccaf02467
+  metadata.gz: 168d33f7e90d7da8680b61455d25b3bfd9d12dfcc05616723ff84abcb17c2ceee14e4336f3ac045798a365933e64ebb341b832be17334de88c4debc80d6e7288
+  data.tar.gz: 8710a7fd7e50b084215a03bd8093f757b026c86b2f9c35d6890a3735619d4e36d819d7f73c77ce887f0c6f293f07e1169bb7573db9bf942bbb8f2538dde35249

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, cmd: 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/dynamic_attribute_declaration.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10"
   spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "guard-rspec", "~> 4.2"
   spec.add_development_dependency "rspec-its", "~> 1"
   spec.add_development_dependency "sqlite3", "~> 1.3"
   spec.add_development_dependency "database_cleaner", "~> 1.3"

data/lib/dynamic_attribute_declaration.rb

@@ -33,24 +33,41 @@ module DynamicAttributeDeclaration
       self._dynamic_attr_state_if = proc
     end
 
-    def define_attrs *args
-      attrs = Hash[*args.flatten]
-      self._dynamic_attrs.merge! attrs
-      build_validations_from_dynamic_attrs attrs
+    def define_attrs args
+      add_dynamic_attrs args
+      build_validations_from_dynamic_attrs args
     end
 
-    def attrs_for state=nil, device=nil
-      if state
-        device ||= :desktop
-        _dynamic_attrs.select do |key, val|
-          if val.class == Symbol
-            comparer = val
-          elsif val.respond_to?(:key) && val.key?(:on)
-            comparer = val[:on] if val[:on].class == Symbol
-            comparer = val[:on][device.to_sym] if val[:on].respond_to?(:key) && val[:on].key?(device.to_sym)
+    def attrs_on_for attr_name
+      attr = _dynamic_attrs[attr_name]
+      rtn = {}
+      attr.each do |a|
+        if a.key? :on
+          obj = a[:on]
+          obj.each do |key, value|
+            if rtn.key? key
+              rtn[key].push(value).flatten!
+            else
+              rtn[key] = value
+            end
           end
+        end
+      end
+      rtn
+    end
+
+    def attrs_for state=nil, device=nil
+      if state && state.to_sym != :all
+        state = state.to_sym
+        device = device ? device.to_sym : nil
+        devices = [:all, device].compact.uniq
 
-          [*comparer].map(&:to_sym).include? state.to_sym
+        _dynamic_attrs.select do |attr_name, definitions|
+          on_attrs = attrs_on_for(attr_name)
+          if on_attrs
+            comparer = (devices & on_attrs.keys).map { |k| on_attrs[k] }.flatten.uniq
+          end
+          comparer.map(&:to_sym).include? state.to_sym
         end
       else
         _dynamic_attrs
@@ -63,13 +80,14 @@ module DynamicAttributeDeclaration
 
     def build_validations_from_dynamic_attrs attrs
       # throw "No validation state if defined" unless _rdynamic_attr_state_if
-      attrs.each do |key, val|
-        if val.key?(:validates) && !val[:validates].empty?
-          opts = val[:validates].deep_symbolize_keys
+      attrs.each do |attr|
+        key, value = *attr.flatten
+        if value.key?(:validates) && !value[:validates].empty?
+          opts = value[:validates].deep_symbolize_keys
 
           # Check if validation should only be used in specific state
-          if val.key?(:on) && _dynamic_attr_state_if && _dynamic_attr_state_if.class == Proc
-            validates_on = val[:on]
+          if value.key?(:on) && _dynamic_attr_state_if && _dynamic_attr_state_if.class == Proc
+            validates_on = value[:on]
             # If validates contains if statement, wrap that statement in state check
             if opts.key?(:if)
               original_if = opts.delete(:if)
@@ -83,6 +101,40 @@ module DynamicAttributeDeclaration
         end
       end
     end
+
+    def add_dynamic_attrs attrs
+      attrs.each do |attr|
+        key, value = *attr.flatten
+        if self._dynamic_attrs.keys.include? key
+          self._dynamic_attrs[key].push process_attr(value)
+        else
+          self._dynamic_attrs[key] = [process_attr(value)]
+        end
+      end
+    end
+
+    def process_attr attr
+      rtn = {}
+      attr.each do |key, value|
+        if key == :on
+          case value
+          when Symbol
+            new_value = { all: [value] }
+          when Array
+            new_value = { all: value }
+          when Hash
+            new_value = {}
+            value.each { |k,v| new_value[k] = *v }
+          else
+            throw "Process attr #{value} cannot be of class #{value.class}"
+          end
+        else
+          new_value = value
+        end
+        rtn[key] = new_value
+      end
+      rtn
+    end
   end
 end
 

data/lib/dynamic_attribute_declaration/version.rb

@@ -1,3 +1,3 @@
 module DynamicAttributeDeclaration
-  VERSION = "0.0.11"
+  VERSION = "0.1.0"
 end

data/spec/lib/base_spec.rb

@@ -4,6 +4,11 @@ describe "BASE TESTS" do
 
   let(:cls) { Phone }
 
+  before do
+    cls.clear_validators!
+    cls.clear_dynamic_attrs!
+  end
+
   describe "Basic gem tests" do
 
     it "Accessor _dynamic_attrs should be Hash" do
@@ -23,49 +28,176 @@ describe "BASE TESTS" do
       expect(cls.validators).to eq []
     end
 
-    describe "Simple definition of presence validator" do
-      let(:defition_array) { [{name:{validates:{presence: true}}}] }
-      let(:definition) { Hash[*defition_array.flatten] }
+    describe "Simple definition of on" do
+
+      types = {
+        "on a symbol" => :right,
+        "on an array" => [:right],
+        "on a hash" => { all: :right }
+      }
+
+      types.each do |name, definition|
+        describe name do
+          before do
+            cls.clear_dynamic_attrs!
+            cls.define_attrs [
+              {
+                name: { on: definition }
+              }
+            ]
+          end
+
+          describe "_dynamic_attrs" do
+            it "Should hold an array comparable to the definition" do
+              expect(cls._dynamic_attrs[:name]).not_to eq nil
+              expect(cls._dynamic_attrs[:name].class).to eq Array
+              expect(cls._dynamic_attrs[:name].length).to eq 1
+            end
+            it "Should hold on defintions comparable to the definition" do
+              cls._dynamic_attrs[:name].each do |attr|
+                expect(attr[:on].class).to eq Hash
+                expect(attr[:on].length).to eq 1
+              end
+            end
+          end
+
+          describe 'attrs_for' do
+            it "With no state should return definition" do
+              expect(cls.attrs_for.keys).to eq [:name]
+            end
+            it "With :all state should return definition" do
+              expect(cls.attrs_for(:all).keys).to eq [:name]
+            end
+            it "With right state should return definition" do
+              expect(cls.attrs_for(:right).keys).to eq [:name]
+            end
+            it "With wrong state should return definition" do
+              expect(cls.attrs_for(:wrong).keys).to eq []
+            end
+          end
 
+          describe 'attrs_names_for' do
+            it "With no state should return definition" do
+              expect(cls.attrs_names_for).to eq [:name]
+            end
+            it "With :all state should return definition" do
+              expect(cls.attrs_names_for(:all)).to eq [:name]
+            end
+            it "With right state should return definition" do
+              expect(cls.attrs_names_for(:right)).to eq [:name]
+            end
+            it "With wrong state should return definition" do
+              expect(cls.attrs_names_for(:wrong)).to eq []
+            end
+          end
+        end
+      end
+    end
+
+    describe "Advanced definition of on" do
       before do
-        cls.define_attrs definition
+        @definition = [
+          {
+            name: { on: :foo }
+          },
+          {
+            name: { on: :bar }
+          }
+        ]
+        cls.define_attrs @definition
       end
 
-      it "Should have at least one validator" do
-        expect(cls.validators).not_to eq []
-        expect(cls.validators.length).to be >= 1
+      describe "_dynamic_attrs" do
+        it "Should hold a hash for the defines on" do
+          expect(cls._dynamic_attrs[:name]).not_to eq nil
+          expect(cls._dynamic_attrs[:name].class).to eq Array
+          expect(cls._dynamic_attrs[:name].length).to eq 2
+        end
+      end
+
+      describe 'attrs_names_for' do
+        it "With no state should return definition" do
+          expect(cls.attrs_names_for).to eq [:name]
+        end
+        it "With :all state should return definition" do
+          expect(cls.attrs_names_for(:all)).to eq [:name]
+        end
+        it "With foo state should return definition" do
+          expect(cls.attrs_names_for(:foo)).to eq [:name]
+        end
+        it "With bar state should return definition" do
+          expect(cls.attrs_names_for(:bar)).to eq [:name]
+        end
+        it "With wrong state should return definition" do
+          expect(cls.attrs_names_for(:wrong)).to eq []
+        end
+      end
+    end
+
+    describe "Simple definition of presence validator" do
+      before do
+        @definition = [
+          {
+            name:
+            {
+              validates: { presence: true }
+            }
+          }
+        ]
+        @definition_keys = @definition.map { |d| d.keys }.flatten
+        cls.define_attrs @definition
       end
 
-      it "Should have a specific validator" do
-        obj = definition
-        name = obj.keys.first
-        validators = obj[name][:validates]
-        validator_type = validators.keys.first
+      describe "validators" do
+        it "Should have at least one validator" do
+          expect(cls.validators).not_to eq []
+          expect(cls.validators.length).to be >= 1
+        end
+
+        it "Should have validators from definition" do
+          definition_validators = @definition.map { |obj|obj.keys.map { |k| obj[k][:validates] } }.flatten
+          definition_validator_classes = definition_validators.map { |validator| validator.keys.map { |k| "ActiveRecord::Validations::#{k.capitalize}Validator".constantize } }.flatten
 
-        validator = cls.validators.first
-        expect(validator.class).to eq "ActiveRecord::Validations::#{validator_type.capitalize}Validator".constantize
+          expect(cls.validators.length).to eq definition_validators.length
+          expect(cls.validators.map(&:class)).to eq definition_validator_classes
+        end
       end
 
-      it "_dynamic_attrs should have configuration from define_attrs" do
-        expect(cls._dynamic_attrs).to eq definition
+      describe "_dynamic_attrs" do
+        it "Should have keys from definition" do
+          expect(cls._dynamic_attrs.keys).to eq @definition_keys
+        end
       end
 
-      it "attrs_for with no state should return definition" do
-        expect(cls.attrs_for).to eq definition
+      describe "attrs_for" do
+        it "With no state should have the same keys as the definition" do
+          response = cls.attrs_for
+          expect(response.class).to eq Hash
+          expect(cls.attrs_for.keys).to eq @definition_keys
+          expect(cls.attrs_for.keys.length).to eq @definition_keys.length
+        end
       end
 
-      it "attrs_names_for with no state should return definition" do
-        expect(cls.attrs_names_for).to eq definition.keys
+      describe "attrs_names_for" do
+        it "With no state should return definition" do
+          expect(cls.attrs_names_for).to eq @definition_keys
+        end
       end
     end
 
     describe "Simple definition of presence validator, with on parameter" do
-      let(:defition_array) { [{name:{validates:{presence: true}, on: :right}}] }
-      let(:definition) { Hash[*defition_array.flatten] }
-      let(:instance) { cls.new }
-
       before do
-        cls.define_attrs definition
+        @definition = [
+          {
+            name:
+            {
+              validates: { presence: true },
+              on: :right
+            }
+          }
+        ]
+        @definition_keys = @definition.map { |d| d.keys }.flatten
+        cls.define_attrs @definition
       end
 
       it "Should have at least one validator" do
@@ -73,52 +205,50 @@ describe "BASE TESTS" do
         expect(cls.validators.length).to be >= 1
       end
 
-      it "Should have a specific validator" do
-        obj = definition
-        name = obj.keys.first
-        validators = obj[name][:validates]
-        validator_type = validators.keys.first
+      it "Should have validators from definition" do
+        definition_validators = @definition.map { |obj|obj.keys.map { |k| obj[k][:validates] } }.flatten
+        definition_validator_classes = definition_validators.map { |validator| validator.keys.map { |k| "ActiveRecord::Validations::#{k.capitalize}Validator".constantize } }.flatten
 
-        validator = cls.validators.first
-        expect(validator.class).to eq "ActiveRecord::Validations::#{validator_type.capitalize}Validator".constantize
+        expect(cls.validators.length).to eq definition_validators.length
+        expect(cls.validators.map(&:class)).to eq definition_validator_classes
       end
 
-      it "_dynamic_attrs should have configuration from define_attrs" do
-        expect(cls._dynamic_attrs).to eq definition
+      it "_dynamic_attrs should have keys from definition" do
+        expect(cls._dynamic_attrs.keys).to eq @definition_keys
       end
 
       describe "attrs_for" do
         it "with no state should return definition" do
-          expect(cls.attrs_for).to eq definition
+          expect(cls.attrs_for.keys).to eq @definition_keys
         end
         describe "with right state" do
           it "with symbol should return definition" do
-            expect(cls.attrs_for(:right)).to eq definition
+            expect(cls.attrs_for(:right).keys).to eq @definition_keys
           end
           it "with string should return definition" do
-            expect(cls.attrs_for("right")).to eq definition
+            expect(cls.attrs_for("right").keys).to eq @definition_keys
           end
         end
         describe "with wrong state" do
           it "with symbol should return empty object" do
-            expect(cls.attrs_for(:wrong)).to eq({})
+            expect(cls.attrs_for(:wrong).keys).to eq []
           end
           it "with string should return empty object" do
-            expect(cls.attrs_for("wrong")).to eq({})
+            expect(cls.attrs_for("wrong").keys).to eq []
           end
         end
       end
 
       describe "attrs_names_for" do
         it "with no state should return definition keys" do
-          expect(cls.attrs_names_for).to eq definition.keys
+          expect(cls.attrs_names_for).to eq @definition_keys
         end
         describe "with right state" do
           it "with symbol should return definition keys" do
-            expect(cls.attrs_names_for(:right)).to eq definition.keys
+            expect(cls.attrs_names_for(:right)).to eq @definition_keys
           end
           it "with string should return definition keys" do
-            expect(cls.attrs_names_for("right")).to eq definition.keys
+            expect(cls.attrs_names_for("right")).to eq @definition_keys
           end
         end
         describe "with wrong state" do

data/spec/spec_helper.rb

@@ -23,4 +23,7 @@ RSpec.configure do |config|
   config.after(:each) do
     DatabaseCleaner.clean
   end
+
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_attribute_declaration
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors:
 - Mikkel Wied Frederiksen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-02 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -133,6 +147,7 @@ files:
 - ".rspec"
 - ".ruby-version"
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile