attributor 2.6.1 → 3.0

data/lib/attributor/types/csv.rb

@@ -29,9 +29,16 @@ module Attributor
       return collection.join(',')
     end
 
+    def self.describe(shallow=false, example: nil)
+      hash = super(shallow)
+      hash.delete(:member_attribute)
+      hash[:example] = example if example
+      hash
+    end
+
     def self.family
       Collection.family
     end
-    
+
   end
 end

data/lib/attributor/types/hash.rb

@@ -1,4 +1,20 @@
 module Attributor
+  class InvalidDefinition < StandardError
+    def initialize(type, cause)
+      type_name = if type.name
+        type.name
+      else
+        type.inspect
+      end
+
+      msg = "Structure definition for type #{type_name} is invalid. The following exception has occurred: #{cause.inspect}"
+      super(msg)
+      @cause = cause
+    end
+
+    attr_reader :cause
+  end
+
   class Hash
 
     MAX_EXAMPLE_DEPTH = 5
@@ -21,6 +37,8 @@ module Attributor
     @key_attribute = Attribute.new(@key_type)
     @value_attribute = Attribute.new(@value_type)
 
+    @error = false
+
 
     def self.key_type=(key_type)
       @key_type = Attributor.resolve_type(key_type)
@@ -37,7 +55,7 @@ module Attributor
     def self.family
       'hash'
     end
-    
+
     @saved_blocks = []
     @options = {allow_extra: false}
     @keys = {}
@@ -54,14 +72,20 @@ module Attributor
         @value_type = v
         @key_attribute = Attribute.new(@key_type)
         @value_attribute = Attribute.new(@value_type)
+
+        @error = false
       end
     end
 
     def self.attributes(**options, &key_spec)
+      raise @error if @error
+
       self.keys(options, &key_spec)
     end
 
     def self.keys(**options, &key_spec)
+      raise @error if @error
+
       if block_given?
         @saved_blocks << key_spec
         @options.merge!(options)
@@ -86,8 +110,9 @@ module Attributor
           map[k.downcase] = k
         end
       end
-      
-      compiler
+    rescue => e
+      @error = InvalidDefinition.new(self, e)
+      raise
     end
 
     def self.dsl_class
@@ -134,10 +159,13 @@ module Attributor
 
 
     def self.example_contents(context, parent, **values)
+
       hash = ::Hash.new
       example_depth = context.size
 
       self.keys.each do |sub_attribute_name, sub_attribute|
+        
+        
         if sub_attribute.attributes
           # TODO: add option to raise an exception in this case?
           next if example_depth > MAX_EXAMPLE_DEPTH
@@ -148,8 +176,8 @@ module Attributor
           value = values.fetch(sub_attribute_name) do
             sub_attribute.example(sub_context, parent: parent)
           end
-
           sub_attribute.load(value,sub_context)
+
         end
 
 
@@ -160,6 +188,7 @@ module Attributor
     end
 
     def self.example(context=nil, **values)
+
       if (key_type == Object && value_type == Object && self.keys.empty?)
         return self.new
       end
@@ -339,7 +368,7 @@ module Attributor
       object.each do |k,v|
         next if k == self.extra_keys
 
-        sub_context = self.generate_subcontext(Attributor::DEFAULT_ROOT_CONTEXT,k)
+        sub_context = self.generate_subcontext(context,k)
         hash.set(k, v, context: sub_context, recurse: recurse)
       end
 
@@ -365,19 +394,20 @@ module Attributor
       object.validate(context)
     end
 
-    def self.describe(shallow=false)
-      hash = super
+    def self.describe(shallow=false, example: nil)
+      hash = super(shallow)
 
       if key_type
-        hash[:key] = {type: key_type.describe}
+        hash[:key] = {type: key_type.describe(true)}
       end
 
       if self.keys.any?
         # Spit keys if it's the root or if it's an anonymous structures
-        if ( !shallow || self.name == nil) && self.keys.any?
+        if ( !shallow || self.name == nil)
           # FIXME: change to :keys when the praxis doc browser supports displaying those. or josep's demo is over.
-          hash[:keys] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
-            sub_attributes[sub_name] = sub_attribute.describe(true)
+          hash[:attributes] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+            sub_example = example.get(sub_name) if example
+            sub_attributes[sub_name] = sub_attribute.describe(true, example: sub_example)
           end
         end
       else
@@ -436,6 +466,10 @@ module Attributor
       end
     end
 
+    def delete(key)
+      @contents.delete(key)
+    end
+
     attr_reader :validating, :dumping
 
     def initialize(contents={})

data/lib/attributor/types/model.rb

@@ -6,11 +6,17 @@ module Attributor
     undef :format
     undef :test rescue nil
 
+    if RUBY_ENGINE =~ /^jruby/
+      # We are "forced" to require it here (in case hasn't been yet) to make sure the added methods have been applied
+      require 'java'
+      # Only to then delete them, to make sure we don't have them clashing with any attributes
+      undef java, javax, org, com
+    end
+
     # Remove undesired methods inherited from Hash
     undef :size
     undef :keys
     undef :values
-    undef :empty? 
     undef :has_key?
 
     @key_type = Symbol
@@ -19,9 +25,10 @@ module Attributor
     @key_attribute = Attribute.new(@key_type)
     @value_attribute = Attribute.new(@value_type)
 
+
     def self.inherited(klass)
       k = self.key_type
-      ka = self.key_attribute 
+      ka = self.key_attribute
 
       v = self.value_type
       va = self.value_attribute
@@ -35,6 +42,8 @@ module Attributor
 
         @key_attribute = ka
         @value_attribute = va
+
+        @error = false
       end
     end
 
@@ -66,12 +75,6 @@ module Attributor
       end
     end
 
-    def self.describe(shallow=false)
-      hash = super
-      hash[:attributes] = hash.delete :keys
-      hash
-    end
-
     def self.check_option!(name, value)
       case name
       when :identity
@@ -89,7 +92,7 @@ module Attributor
     end
 
     def self.generate_subcontext(context, subname)
-      context + [subname] 
+      context + [subname]
     end
 
     def self.example(context=nil, **values)
@@ -176,7 +179,7 @@ module Attributor
 
       self.attributes.each_with_object({}) do |(name, value), result|
         attribute = self.class.attributes[name]
-        
+
         # skip dumping undefined attributes
         unless attribute
           warn "WARNING: Trying to dump unknown attribute: #{name.inspect} with context: #{context.inspect}"

data/lib/attributor/types/string.rb

@@ -18,16 +18,16 @@ module Attributor
 
     def self.example(context=nil, options:{})
       if options[:regexp]
-        return options[:regexp].gen
+        # It may fail to generate an example, see bug #72.
+        options[:regexp].gen rescue ('Failed to generate example for %s' % options[:regexp].inspect)
       else
-        return /\w+/.gen
+        /\w+/.gen
       end
     end
 
     def self.family
       'string'
     end
-    
+
   end
-  
 end

data/lib/attributor/types/uri.rb

@@ -0,0 +1,57 @@
+# Represents a href type.
+require 'uri'
+
+module Attributor
+  class URI
+    include Attributor::Type
+
+    def self.family
+      String.family
+    end
+
+    def self.valid_type?(value)
+      case value
+      when ::String, ::URI::Generic
+        true
+      else
+        false
+      end
+    end
+
+    def self.native_type
+      return ::URI::Generic
+    end
+
+    def self.example(context=nil, options={})
+      URI(/[:uri:]/.gen)
+    end
+
+    def self.load(value, context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      return nil if value.nil?
+      case value
+      when self.native_type
+        value
+      when ::String
+        URI(value)
+      else
+        raise CoercionError, context: context, from: value.class, to: self, value: value
+      end
+    end
+
+    def self.validate(value,context=Attributor::DEFAULT_ROOT_CONTEXT,attribute)
+      []
+    end
+
+    def check_option!(name, definition)
+      # No options are supported
+      :unknown
+    end
+
+  end
+end
+
+class Randgen
+  def self.uri
+    "http://example.com/#{word}/#{rand(10 ** 9)}"
+  end
+end

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = "2.6.1"
+  VERSION = "3.0"
 end

data/spec/attribute_spec.rb

@@ -93,6 +93,48 @@ describe Attributor::Attribute do
       end
 
     end
+
+    context 'with an example' do
+
+      let(:attribute_options){ {} }
+      let(:example){ attribute.example }
+      subject(:described){ attribute.describe(false, example: example) }
+
+      context 'using a simple terminal type' do
+        let(:type) { String }
+        its(:keys){ should include(:example) }
+        it 'should have the passed example value' do
+          described.should have_key(:example)
+          described[:example].should eq(example)
+        end
+        it 'should have removed the example from the :type' do
+          described[:type].should_not have_key(:example)
+        end
+
+      end
+
+      context 'using a complex type' do
+        let(:type) { Cormorant }
+        its(:keys){ should_not include(:example) }
+
+        it 'Should see examples in the right places, depending on leaf/no-leaf types' do
+          # String, a leaf attribute type: should have example
+          name_attr =  described[:type][:attributes][:name]
+          name_attr.should include(:example)
+          name_attr[:type].should_not include(:example)
+
+          # Struct, a non-leaf attribute type: shouldn't have example
+          ts_attr =  described[:type][:attributes][:timestamps]
+          ts_attr.should_not include(:example)
+          ts_attr[:type].should_not include(:example)
+
+          # DateTime inside a Struct, a nested leaf attribute type: should have example
+          born_attr =  ts_attr[:type][:attributes][:born_at]
+          born_attr.should include(:example)
+          born_attr[:type].should_not include(:example)
+        end
+      end
+    end
   end
 
 
@@ -135,10 +177,8 @@ describe Attributor::Attribute do
     end
   end
 
-
   context 'example' do
     let(:example) { nil }
-    let(:attribute_options) { {:example => example} }
 
     context 'with nothing specified' do
       let(:attribute_options) { {} }
@@ -151,108 +191,141 @@ describe Attributor::Attribute do
       end
     end
 
+    context 'with an attribute that has the values option set' do
+      let(:values) { ["one", "two"] }
+      let(:attribute_options) { {:values => values} }
+      it 'picks a random value' do
+        values.should include subject.example
+      end
+
+    end
+
+    context 'deterministic examples' do
+      let(:example) { /\w+/ }
+      let(:attribute_options) { {:example => example} }
+
+      it 'can take a context to pre-seed the random number generator' do
+        example_1 = subject.example(['context'])
+        example_2 = subject.example(['context'])
+
+        example_1.should eq example_2
+      end
+
+      it 'can take a context to pre-seed the random number generator' do
+        example_1 = subject.example(['context'])
+        example_2 = subject.example(['different context'])
+
+        example_1.should_not eq example_2
+      end
+    end
+
+    context 'with an example option' do
+      let(:example){ "Bob" }
+      let(:attribute_options) { {example: example , regexp: /Bob/ } }
+
+      its(:example){ should == example }
+
+      context 'that is not valid' do
+        let(:example){ "Frank" }
+        it 'raises a validation error' do
+          expect{
+            subject.example
+          }.to raise_error(Attributor::AttributorException, /Error generating example/)
+        end
+      end
+    end
+  end
+
+  context 'example_from_options' do
+    let(:example) { nil }
+    let(:generated_example) { example }
+    let(:attribute_options) { {:example => example} }
+    let(:parent){ nil }
+    let(:context){ Attributor::DEFAULT_ROOT_CONTEXT}
+
+    subject(:example_result) { attribute.example_from_options( parent, context ) }
+    before do
+      attribute.should_receive(:load).with( generated_example , an_instance_of(Array) ).and_call_original
+    end
 
     context 'with a string' do
       let(:example) { "example" }
 
-      its(:example) { should be example }
+      it { should be example }
+    end
+
+    context 'with an integer' do
+      let(:type) { Attributor::Integer }
+      let(:example) { 5 }
+      it { should be example }
     end
 
     context 'with a regexp' do
       let(:example) { /\w+/ }
-
+      let(:generated_example) { /\w+/.gen }
 
       it 'calls #gen on the regexp' do
-        example.should_receive(:gen).and_call_original
-        subject.example.should =~ example
+        example.should_receive(:gen).and_return(generated_example)
+
+        example_result.should =~ example
       end
 
       context 'for a type with a non-String native_type' do
         let(:type) { Attributor::Integer }
-        context 'using a regexp' do
-          let(:example) { /\d{5}/ }
-          it 'coerces the example value properly' do
-            example.should_receive(:gen).and_call_original
-            type.should_receive(:load).and_call_original
-  
-            subject.example.should be_kind_of(type.native_type)
-          end
-        end
-        context 'usign a native Integer type' do
-          let(:example) { 5 }
-          it 'coerces the example value properly' do
-            type.should_receive(:load).and_call_original
-            subject.example.should be_kind_of(type.native_type)
-          end          
+        let(:example) { /\d{5}/ }
+        let(:generated_example) { /\d{5}/.gen }
+
+        it 'coerces the example value properly' do
+          example.should_receive(:gen).and_return(generated_example)
+          type.should_receive(:load).and_call_original
+
+          example_result.should be_kind_of(type.native_type)
         end
       end
-    end
 
+    end
 
     context 'with a proc' do
+      let(:parent){ Object.new }
+
       context 'with one argument' do
         let(:example) { lambda { |obj| 'ok' } }
-        let(:some_object) { Object.new }
+        let(:generated_example) { 'ok' }
 
         before do
-          example.should_receive(:call).with(some_object).and_call_original
+          example.should_receive(:call).with(parent).and_return(generated_example)
         end
 
         it 'passes any given parent through to the example proc' do
-          subject.example(nil, parent: some_object).should == 'ok'
+          example_result.should == 'ok'
         end
       end
 
       context 'with two arguments' do
         let(:example) { lambda { |obj, context| "#{context} ok" } }
-        let(:some_object) { Object.new }
-        let(:some_context) { ['some_context'] }
-
+        let(:generated_example) { "#{context} ok" }
+        let(:context){ ['some_context'] }
         before do
-          example.should_receive(:call).with(some_object, some_context).and_call_original
+          example.should_receive(:call).with(parent, context).and_return(generated_example)
         end
 
         it 'passes any given parent through to the example proc' do
-          subject.example(some_context, parent: some_object).should == "#{some_context} ok"
+          example_result.should == "#{context} ok"
         end
       end
 
     end
 
     context 'with an array' do
-      let(:example) { ["one", "two"] }
-      it 'picks a random value' do
-        example.should include subject.example
-      end
-    end
-
-    context 'with an attribute that has the values option set' do
-      let(:values) { ["one", "two"] }
-      let(:attribute_options) { {:values => values} }
+      let(:example) { ["one"] }
+      let(:generated_example) { "one" }
       it 'picks a random value' do
-        values.should include subject.example
+        example.should_receive(:pick).and_call_original
+        example.should include example_result
       end
 
     end
 
-    context 'deterministic examples' do
-      let(:example) { /\w+/ }
-      it 'can take a context to pre-seed the random number generator' do
-        example_1 = subject.example(['context'])
-        example_2 = subject.example(['context'])
-
-        example_1.should eq example_2
-      end
-
-      it 'can take a context to pre-seed the random number generator' do
-        example_1 = subject.example(['context'])
-        example_2 = subject.example(['different context'])
-
-        example_1.should_not eq example_2
-      end
-
-      
-    end
   end
 
   context 'load' do
@@ -286,7 +359,7 @@ describe Attributor::Attribute do
         it { should == default_value}
 
       end
-      
+
       context 'for a Proc-based default value' do
         let(:context){ ["$"] }
         subject(:result){ attribute.load(value,context) }
@@ -296,21 +369,21 @@ describe Attributor::Attribute do
           let(:default_value) { proc { "no_params" } }
           it { should == default_value.call }
         end
-        
+
         context 'with 1 argument (the parent)' do
           let(:default_value) { proc {|parent| "parent is fake: #{parent.class}" } }
           it { should == "parent is fake: Attributor::FakeParent" }
         end
-        
+
         context 'with 2 argument (the parent and the contents)' do
           let(:default_value) { proc {|parent,context| "parent is fake: #{parent.class} and context is: #{context}" } }
           it { should == "parent is fake: Attributor::FakeParent and context is: [\"$\"]"}
         end
-        
+
         context 'which attempts to use the parent (which is not supported for the moment)' do
           let(:default_value) { proc {|parent| "any parent method should spit out warning: [#{parent.something}]" } }
           it "should output a warning" do
-            begin 
+            begin
               old_verbose, $VERBOSE = $VERBOSE, nil
               Kernel.should_receive(:warn).and_call_original
               attribute.load(value,context).should == "any parent method should spit out warning: []"
@@ -638,7 +711,6 @@ describe Attributor::Attribute do
       let(:type) { Attributor::Collection.of(member_type) }
       let(:member_options) { {} }
 
-
       context 'the member_attribute of that type' do
         subject(:member_attribute) { attribute.type.member_attribute }
         it { should be_kind_of(Attributor::Attribute)}