dockly-util 0.0.5 → 0.0.6

data/lib/dockly/util/dsl.rb

@@ -22,29 +22,64 @@ module Dockly::Util::DSL
     end
     private :dsl_attribute
 
-    def dsl_class_attribute(name, klass)
+    def dsl_class_attribute(name, klass, options={})
       unless klass.ancestors.include?(Dockly::Util::DSL)
-        raise "#{self.class}.dsl_class_attribute requires a class that includes DSL"
-      end
-      define_method(name) do |sym = nil, &block|
-        new_value = case
-                    when !block.nil? && !sym.nil? then klass.new!(:name => sym, &block)
-                    when block.nil?               then klass.instances[sym]
-                    when sym.nil?                 then klass.new!(:name => :"#{self.name}_#{klass}", &block)
-                    end
-        instance_variable_set(:"@#{name}", new_value) unless new_value.nil?
-        instance_variable_get(:"@#{name}")
+        raise "#{self}.dsl_class_attribute requires a class that includes DSL"
       end
+      type = options.delete(:type) || Object
+      generated_related_name = :"#{self.underscore(self.demodulize(self.to_s))}"
+      related_name = options.delete(:related_name) || generated_related_name
+      define_forward_relation(name, related_name, self, klass, type)
+      define_reverse_relation(related_name, name, klass, self)
     end
     private :dsl_class_attribute
 
+    def define_forward_relation(name, related_name, current_class, klass, type)
+      current_class.instance_eval do
+        define_method(name) do |sym = nil, &block|
+          new_value = case
+                      when !block.nil? && !sym.nil? then klass.new!(:name => sym, &block)
+                      when block.nil?               then klass.instances[sym]
+                      when sym.nil?                 then klass.new!(:name => :"#{self.name}_#{klass}", &block)
+                      end
+          unless new_value.nil?
+            if type.ancestors.include? Array
+              val = instance_variable_get(:"@#{name}") || []
+              instance_variable_set(:"@#{name}", val + [new_value])
+            else
+              instance_variable_set(:"@#{name}", new_value)
+            end
+            new_value.instance_variable_set(
+              :"@#{related_name}",
+              self
+            )
+          end
+          instance_variable_get(:"@#{name}")
+        end
+      end
+    end
+    private :define_forward_relation
+
+    def define_reverse_relation(name, related_name, current_class, klass)
+      current_class.instance_eval do
+        define_method(name) do
+          instance_variable_get(:"@#{name}")
+        end
+      end
+    end
+    private :define_reverse_relation
+
     def default_value(name, val = nil)
       default_values[name] = block_given? ? yield : val
     end
     private :default_value
 
     def default_values
-      @default_values ||= {}
+      @default_values ||= if self.superclass.respond_to?(:default_values)
+        self.superclass.default_values
+      else
+        {}
+      end
     end
 
     def instances
@@ -59,6 +94,17 @@ module Dockly::Util::DSL
       end
     end
 
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!('::', '/')
+      word.gsub!(/(?:([A-Za-z\d])|^)(#{/(?=a)b/})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
     def generate_unique_name
       name = nil
       (0..(1.0 / 0.0)).each do |n|

data/lib/dockly/util/version.rb

@@ -1,5 +1,5 @@
 module Dockly
   module Util
-    VERSION = '0.0.5'
+    VERSION = '0.0.6'
   end
 end

data/spec/dockly/util/dsl_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+class IncludedClass
+  include Dockly::Util::DSL
+
+  dsl_attribute :ocean
+end
+
+class TestClass
+  include Dockly::Util::DSL
+
+  dsl_attribute :chips
+  dsl_class_attribute :meta, IncludedClass
+end
+
+class ArrayClass
+  include Dockly::Util::DSL
+
+  dsl_class_attribute :attr, IncludedClass, type: Array
+end
+
+describe Dockly::Util::DSL do
+  let(:included_class) { IncludedClass }
+  let(:test_class) { TestClass }
+  let(:array_class) { ArrayClass }
+
+  let(:test_instance) { test_class.new!(:name => 'Tony') }
+  let(:array_instance) { array_class.new! }
+
+  describe '.dsl_attribute' do
+    it 'defines a method for each name given' do
+      test_instance.should respond_to :chips
+    end
+
+    context 'the defined method(s)' do
+      context 'with 0 arguments' do
+        let(:test_val) { 'lays' }
+        before { test_instance.instance_variable_set(:@chips, test_val) }
+
+        it 'returns the value of the instance variable with a matching name' do
+          test_instance.chips.should == test_val
+        end
+      end
+
+      context 'with one argument' do
+        it 'sets the corresponding instance variable to the passed-in value' do
+          expect { test_instance.chips('bbq') }
+              .to change { test_instance.instance_variable_get(:@chips) }
+              .to 'bbq'
+        end
+      end
+    end
+  end
+
+  describe '.dsl_class_attribute' do
+    context 'when the sceond argument is not a DSL' do
+      it 'raises an error' do
+        expect do
+          Class.new do
+            include Dockly::Util::DSL
+
+            dsl_class_attribute :test, Array
+          end
+        end.to raise_error
+      end
+    end
+
+    context 'when the second argument is a DSL' do
+      it 'defines a new method with the name of the first argument' do
+        test_instance.should respond_to :meta
+        array_instance.should respond_to :attr
+      end
+
+      it 'defines a new method on the DSL class with the name of the current class' do
+        included_class.new.should respond_to :test_class
+        included_class.new.should respond_to :array_class
+      end
+
+      context 'the method' do
+        context 'for a regular class attribute' do
+          let(:meta) { test_instance.instance_variable_get(:@meta) }
+
+          context 'when a symbol is given' do
+            context 'and a block is given' do
+              before { test_instance.meta(:yolo) { ocean 'Indian' } }
+
+              it 'creates a new instance of the specified Class with the name set' do
+                meta.name.should == :yolo
+                meta.ocean.should == 'Indian'
+              end
+            end
+
+            context 'and a block is not given' do
+              before { included_class.new!(:name => :test_name) { ocean 'Pacific' } }
+
+              it 'looks up the instance in its Class\'s .instances hash' do
+                test_instance.meta(:test_name).ocean.should == 'Pacific'
+              end
+            end
+          end
+
+          context 'when a symbol is not given' do
+            context 'and a block is given' do
+              before { test_instance.meta { ocean 'Atlantic' } }
+
+              it 'creates a new instance of the specified Class' do
+                meta.ocean.should == 'Atlantic'
+              end
+
+              it 'generates a name' do
+                meta.name.should == :"#{test_instance.name}_#{meta.class}"
+              end
+            end
+
+            context 'and a block is not given' do
+              before { test_instance.meta(:test) { ocean 'Artic' } }
+
+              it 'returns the corresponding instance variable' do
+                test_instance.meta.should == meta
+              end
+            end
+          end
+        end
+
+        context 'for an array class attribute' do
+          let(:attr) { array_instance.instance_variable_get(:@attr) }
+
+          context 'when a symbol is given' do
+            context 'and a block is given' do
+              before { array_instance.attr(:yolo) { ocean 'Indian' } }
+
+              it 'creates a new instance of the specified Class with the name set' do
+                expect(attr.length).to be == 1
+                expect(attr.first.ocean).to be == 'Indian'
+              end
+            end
+
+            context 'and a block is not given' do
+              before { included_class.new!(:name => :test_name) { ocean 'Pacific' } }
+
+              it 'looks up the instance in its Class\'s .instances hash' do
+                expect(array_instance.attr(:test_name).first.ocean).to be == 'Pacific'
+              end
+            end
+          end
+
+          context 'when a symbol is not given' do
+            context 'and a block is given' do
+              before { array_instance.attr { ocean 'Atlantic' } }
+
+              it 'creates a new instance of the specified Class' do
+                attr.first.ocean.should == 'Atlantic'
+              end
+
+              it 'generates a name' do
+                attr.first.name.should == :"#{array_instance.name}_#{IncludedClass.to_s}"
+              end
+            end
+
+            context 'and a block is not given' do
+              before { array_instance.attr(:test) { ocean 'Artic' } }
+
+              it 'returns the corresponding instance variable' do
+                array_instance.attr.should == attr
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#ensure_present!' do
+    context 'when at least one of the symbols is nil' do
+      it 'raises an error' do
+        expect { test_instance.send(:ensure_present!, :meta) }.to raise_error
+      end
+    end
+
+    context 'when each symbol is present' do
+      it 'does nothing' do
+        expect { test_instance.send(:ensure_present!, :name) }.to_not raise_error
+      end
+    end
+  end
+
+  describe '.default_value' do
+    context 'when a block is given' do
+      it 'calls the block and adds it to he default_values hash' do
+        test_class.send(:default_value, :meta) { included_class.new!(:name => :joey) }
+        test_class.default_values[:meta].name.should == :joey
+      end
+    end
+
+    context 'when a value is given' do
+      it 'adds the pair to the default_values hash' do
+        test_class.send(:default_value, :chips, 'Cool Ranch')
+        test_class.default_values[:chips].should == 'Cool Ranch'
+      end
+    end
+  end
+
+  describe '#initialize' do
+    context 'when a block is given' do
+      it 'is instance evaluated' do
+        test_class.new! { name :timmy }.name.should == :timmy
+      end
+    end
+
+    context 'when a hash is given' do
+      it 'sends each key value pair to the object as a message' do
+        test_class.new!(:name => :tommy).name.should == :tommy
+      end
+    end
+
+    context 'when there is a name' do
+      it 'adds the current instance to the class\'s instances hash' do
+        test_class.instances[:jillian].should be_nil
+        test_class.new! { name :jillian }
+        test_class.instances[:jillian].name.should == :jillian
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rspec'
+require 'pry'
 require 'dockly/util'
 
 RSpec.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dockly-util
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-07 00:00:00.000000000 Z
+date: 2013-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -98,8 +98,8 @@ files:
 - lib/dockly/util/dsl.rb
 - lib/dockly/util/logger.rb
 - lib/dockly/util/version.rb
-- spec/dockl/util/dsl_spec.rb
-- spec/dockl/util/logger_spec.rb
+- spec/dockly/util/dsl_spec.rb
+- spec/dockly/util/logger_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/swipely/dockly-util
 licenses:
@@ -127,7 +127,7 @@ signing_key:
 specification_version: 3
 summary: DSL made easy
 test_files:
-- spec/dockl/util/dsl_spec.rb
-- spec/dockl/util/logger_spec.rb
+- spec/dockly/util/dsl_spec.rb
+- spec/dockly/util/logger_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/dockl/util/dsl_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-
-describe Dockly::Util::DSL do
-  let(:included_class) do
-    Class.new do
-      include Dockly::Util::DSL
-
-      dsl_attribute :ocean
-    end
-  end
-
-  let(:test_class) do
-    klass = included_class
-    Class.new do
-      include Dockly::Util::DSL
-
-      dsl_attribute :chips
-      dsl_class_attribute :meta, klass
-    end
-  end
-
-  subject { test_class.new!(:name => 'Tony') }
-
-  describe '.dsl_attribute' do
-    it 'defines a method for each name given' do
-      subject.should respond_to :chips
-    end
-
-    context 'the defined method(s)' do
-      context 'with 0 arguments' do
-        let(:test_val) { 'lays' }
-        before { subject.instance_variable_set(:@chips, test_val) }
-
-        it 'returns the value of the instance variable with a matching name' do
-          subject.chips.should == test_val
-        end
-      end
-
-      context 'with one argument' do
-        it 'sets the corresponding instance variable to the passed-in value' do
-          expect { subject.chips('bbq') }
-              .to change { subject.instance_variable_get(:@chips) }
-              .to 'bbq'
-        end
-      end
-    end
-  end
-
-  describe '.dsl_class_attribute' do
-    context 'when the sceond argument is not a DSL' do
-      it 'raises an error' do
-        expect do
-          Class.new do
-            include Dockly::Util::DSL
-
-            dsl_class_attribute :test, Array
-          end
-        end.to raise_error
-      end
-    end
-
-    context 'when the second argument is a DSL' do
-      it 'defines a new method with the name of the first argument' do
-        subject.should respond_to :meta
-      end
-
-      context 'the method' do
-        let(:meta) { subject.instance_variable_get(:@meta) }
-
-        context 'when a symbol is given' do
-          context 'and a block is given' do
-            before { subject.meta(:yolo) { ocean 'Indian' } }
-
-            it 'creates a new instance of the specified Class with the name set' do
-              meta.name.should == :yolo
-              meta.ocean.should == 'Indian'
-            end
-          end
-
-          context 'and a block is not given' do
-            before { included_class.new!(:name => :test_name) { ocean 'Pacific' } }
-
-            it 'looks up the instance in its Class\'s .instances hash' do
-              subject.meta(:test_name).ocean.should == 'Pacific'
-            end
-          end
-        end
-
-        context 'when a symbol is not given' do
-          context 'and a block is given' do
-            before { subject.meta { ocean 'Atlantic' } }
-
-            it 'creates a new instance of the specified Class' do
-              meta.ocean.should == 'Atlantic'
-            end
-
-            it 'generates a name' do
-              meta.name.should == :"#{subject.name}_#{meta.class}"
-            end
-          end
-
-          context 'and a block is not given' do
-            before { subject.meta(:test) { ocean 'Artic' } }
-
-            it 'returns the corresponding instance variable' do
-              subject.meta.should == meta
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#ensure_present!' do
-    context 'when at least one of the symbols is nil' do
-      it 'raises an error' do
-        expect { subject.send(:ensure_present!, :meta) }.to raise_error
-      end
-    end
-
-    context 'when each symbol is present' do
-      it 'does nothing' do
-        expect { subject.send(:ensure_present!, :name) }.to_not raise_error
-      end
-    end
-  end
-
-  describe '.default_value' do
-    context 'when a block is given' do
-      it 'calls the block and adds it to he default_values hash' do
-        test_class.send(:default_value, :meta) { included_class.new!(:name => :joey) }
-        test_class.default_values[:meta].name.should == :joey
-      end
-    end
-
-    context 'when a value is given' do
-      it 'adds the pair to the default_values hash' do
-        test_class.send(:default_value, :chips, 'Cool Ranch')
-        test_class.default_values[:chips].should == 'Cool Ranch'
-      end
-    end
-  end
-
-  describe '#initialize' do
-    context 'when a block is given' do
-      it 'is instance evaluated' do
-        test_class.new! { name :timmy }.name.should == :timmy
-      end
-    end
-
-    context 'when a hash is given' do
-      it 'sends each key value pair to the object as a message' do
-        test_class.new!(:name => :tommy).name.should == :tommy
-      end
-    end
-
-    context 'when there is no name' do
-      it 'raises an error' do
-        expect { test_class.new! { chips 'Tortilla' } }.to raise_error
-      end
-    end
-
-    context 'when there is a name' do
-      it 'adds the current instance to the class\'s instances hash' do
-        test_class.instances[:jillian].should be_nil
-        test_class.new! { name :jillian }
-        test_class.instances[:jillian].name.should == :jillian
-      end
-    end
-  end
-end