blobject 0.1.5 → 0.1.9

data/.pryrc

@@ -0,0 +1,7 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'ruby-debug'
+require 'blobject'
+
+def reload!
+  load 'blobject.rb'
+end

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/TODO.txt

@@ -0,0 +1,20 @@
+
+EXAMPLES
+  > to/from yaml
+  > with controller params
+  > JSON response
+  > DSL
+  > Config
+  >>> can make config maintainable by translating it
+
+
+> benefits: configuration ease
+> using hashes with config/json and active record because of key symbolization
+
+
+
+EXTRAS:
+
+> load_config, monitor for changes
+
+automatically handle json request params into blobjects

data/blobject.gemspec

@@ -14,9 +14,10 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "blobject"
   
-  s.add_dependency 'wirble'
-  s.add_dependency 'shoulda'
-
+  
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'ruby-debug19'
+  
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/lib/blobject.rb

@@ -1,175 +1,169 @@
-Dir["#{File.dirname __FILE__}/blobject/*.rb"].each {|file| require "#{file}" }        
+require 'blobject/version'
 
 def blobject *parameters, &block
   Blobject.new *parameters, &block
-end 
+end
 
-# similar to OpenStruct
-# b.foo.bar = 8 automatically creates a blobject called "foo" on "b"
-# to check whether a variable is defined use the '?' syntax i.e: b.is_it_here? => nil, b.foo? == b.foo
-# calling an unassigned member returns a new blobject unless the blobject is frozen
-# a frozen blobject cannot be assigned new members or populated from a hash 
-# does no cycle checking, intended for use in serialization          
 class Blobject
-  class AssignToFrozenBlobjectException < Exception; end
   
-public
-  
-  def frozen?
-    @blobject_frozen == true
+  def initialize hash = {}, &block
+    @hash = {}
+    merge hash
+    
+    @modifying = false
+    self.modify &block if block_given?
   end
   
-  def freeze
-    @blobject_frozen = true
-    self
-  end
-  def unfreeze
-    @blobject_frozen = false
-    self
-  end
-  def defrost
-    unfreeze
-  end
-  
-  def initialize hash_of_initial_values_or_an_object={}, array_of_methods_to_copy_data_from_object=[]
-     @values = {}
-     
-     if (hash_of_initial_values_or_an_object.class == Hash)
-       merge_hash hash_of_initial_values_or_an_object
-     else
-       array_of_methods_to_copy_data_from_object.each do |accessor|
-         @values[accessor.to_s] = hash_of_initial_values_or_an_object.send accessor
-       end
-     end     
-     
-     if block_given?
-       yield self
-     end 
-     self
-  end
-  
-  def method_missing(sym, *args, &block)
-    # fixes for ruby 1.9.2, otherwise blobjects can't be used in arrays that may have the flatten method called
-    super if [:to_ary].include? sym
+  def modify &block
     
-    str = sym.to_s
+    __r_modify_set__ true
     
-    assignment = /.*(?=\=$)/.match str
-    question = /.*(?=\?$)/.match str
+    exception = nil
     
-    if question
-      !@values[question.to_s].nil?
-    elsif assignment
-      raise AssignToFrozenBlobjectException if @blobject_frozen
-      @values[assignment.to_s] = args[0]
-    else
-      #return the value or a new blobject
-      value = @values[str]
+    begin
+      self.instance_eval &block
+    rescue Exception => e
+      exception = e
+    end
+    
+    __r_modify_set__ false
+    
+    raise exception unless exception.nil?
+    return self
+  end
+  
+  def method_missing sym, *params, &block
+    
+    if match = /^has_(?<name>.+)\?/.match(sym)
+      return @hash.has_key? match[:name].to_sym
+    end
+    
+    modify_getter = -> { params.length == 0 && @modifying }
+    modify_assign = -> { params.length == 1 && @modifying }
+        
+    if @modifying
       
-      return value unless value.nil?
-      return nil if frozen?
-      @values[str] = Blobject.new
-      return @values[str]      
+      case params.length
+      when 0 # get
+        return @hash[sym] if @hash.has_key? sym
+        
+        child = Blobject.new
+        parent = self
+        
+        child.__r_modify_set__ true
+        
+        store_in_parent = lambda {
+          
+          parent_hash = parent.instance_variable_get '@hash'
+          parent_hash[sym] = child
+
+          parent_store_in_parent = parent.instance_variable_get :@__store_in_parent__
+          parent_store_in_parent.call unless parent_store_in_parent.nil?
+          
+          child.method(:remove_instance_variable).call(:@__store_in_parent__)
+        }
+        
+        child.instance_variable_set :@__store_in_parent__, store_in_parent
+        
+        return block_given? ? child.modify(&block) : child
+      when 1 # set
+        @hash[sym] = params[0]
+        
+        store_in_parent = @__store_in_parent__
+        store_in_parent.call unless store_in_parent.nil?
+        
+        return self
+      end 
+    else
+      return @hash[sym] if @hash.has_key? sym
     end
+    
+    super
   end
   
-  def merge_hash hash
-    raise "cannot populate a frozen blobject" if @blobject_frozen
+  def merge hash
     
     hash.each do |key, value|
-      
-      if value.class==Hash
-        value = Blobject.new value
-      end
-      
-      if value.class==Array
-        value = Blobject.blobjectify_array value
-      end
-      
-      @values[key.to_s] = value
+      @hash[key.to_s.to_sym] = self.class.__blobjectify__ value
     end 
+    
     self
-  end  
+  end
+  
+  def empty?
+    @hash.empty?
+  end
+  
+  def [] key
+    @hash[key]
+  end
+  
+  def []= key, value
+    send key, value
+  end
   
   def to_hash
-    h = {}
-    @values.each do |key, value|
-      if value.class==Blobject
-        h[key] = value.to_hash
-      elsif value.class==Array
-        h[key] = Blobject.deblobjectify_array value
-      else
-        h[key] = value
-      end
-    end
-    h
+    Marshal.load(Marshal.dump(@hash))
   end
   
-  #builds a hash for json conversion
-  def as_json *ps
-    to_hash
+  def from_hash hash
+    Blobject.new hash
   end
   
-  def self.from_json json, freeze=true
-    h = ActiveSupport::JSON.decode(json)
-    if h.class==Hash
-      b = Blobject.new h 
-      b.freeze if freeze
-      return b
-    elsif h.class==Array
-      return blobjectify_array h
-    else
-      return h
-    end
-  end  
-  
-  def self.blobjectify_array array
-    array.map do |e|
-      if e.class==Hash
-        Blobject.new(e) 
-      elsif e.class==Array
-        blobjectify_array(e)
-      else
-        e
-      end
-    end
+  def to_yaml *params
+    @hash.to_yaml *params
   end
   
-  def self.deblobjectify_array array
-    array.map do |e|
-      if e.class==Blobject
-        e.to_hash 
-      elsif e.class==Array
-        deblobjectify_array(e)
-      else
-        e
-      end
-    end
+  def self.from_yaml yaml
+    __blobjectify__ YAML.load(yaml)
   end
   
-  def [] key
-    @values[key]
+  def to_json *params
+    @hash.to_json *params
   end
   
-  def []= key, value
-    @values[key] = value
+  def self.from_json json
+    __blobjectify__ JSON.load(json)
   end
   
-  def blank?
-    empty?
+  def dup
+    Blobject.new to_hash
   end
   
-  def empty?
-    @values.empty? || @values.values.empty? || !@values.values.any? do |v|
-      #if the value is a Blobject, Hash or Array return
-      #true if it is not empty.
-      #else just return true, the value is regarded as not empty.
-      if [Blobject, Array, Hash].include?(v.class) 
-        !v.empty?
-      else
-        true
+  def inspect
+    @hash.inspect
+  end
+
+  
+
+protected
+  
+  def self.__blobjectify__ obj
+    
+    if obj.instance_of?(Hash)
+      
+      obj.each do |key, value|
+        obj[key] = __blobjectify__ value
+      end
+      
+      return self.new obj
+    end
+    
+    if obj.instance_of?(Array)
+      return obj.map do |e|
+        __blobjectify__ e
+      end
+    end
+    
+    obj
+  end 
+  
+  def __r_modify_set__ modifying
+    @modifying = modifying
+    @hash.values.each do |child|
+      if child.class <= Blobject
+        child.__r_modify_set__ modifying
       end
     end
   end
-  
-end    
+end

data/lib/blobject/version.rb

@@ -1,3 +1,3 @@
 class Blobject
-  VERSION = "0.1.5"
-end
+  VERSION = '0.1.9'
+end

data/spec/blobject_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'blobject'
+
+describe Blobject do
+  
+  let(:blobject){Blobject.new}
+  
+  it 'should not be able to assign to a blobject outside of a modify block using =' do
+    expect {
+      blobject.name = 'hello'
+     
+    }.to raise_error
+  end
+  
+  it 'should not be able to assign to a blobject outside of a modify block without =' do
+    expect {
+      blobject.name 'hello'
+    }.to raise_error
+  end  
+    
+  it 'should raise an error when call members that have not been assign' do
+    
+    expect {
+      blobject.meow
+    }.to raise_error(NoMethodError)
+  end
+  
+  describe '#empty?' do
+    it 'should return true on an empty blobject' do
+      blobject.should be_empty
+    end
+    
+    it 'should return false on an non-empty blobject' do
+      blobject.modify { name "Barry" }
+      blobject.should_not be_empty
+    end
+  end
+  
+  describe '#modify' do
+    
+    it 'should store assignment of variables to any depth in the object graph' do
+      
+      b = blobject.modify do
+        variable 'hello'
+        deep.object.graph.member 123
+      end
+      
+      blobject.variable.should == 'hello'
+      blobject.deep.object.graph.member.should == 123
+    end
+    
+    it 'should not handle more than one parameter' do
+      expect {
+        blobject.modify do
+          name(1, 2)
+        end
+      }.to raise_error(NoMethodError)
+    end
+    
+    it 'should return an empty blobject when a non-existing member is called' do
+      blobject.modify do
+        b = name
+        name.should be_instance_of Blobject
+        name.should be_empty
+      end
+    end
+    
+    it 'should allow assignment chaining' do
+      blobject.modify do
+        name.first('Barry').last('Watkins')
+      end
+      
+      blobject.name.first.should == 'Barry'
+      blobject.name.last.should == 'Watkins'
+    end
+  
+    it 'should return self' do
+      rtn = blobject.modify {}
+      rtn.should equal blobject
+    end
+    
+    it 'should allow for nested modification blocks' do
+      
+      blobject.modify do
+        name do
+          first 'barry'
+          last 'mcdoodle'
+        end
+      end
+      
+      blobject.name.first.should == 'barry'
+      blobject.name.last.should == 'mcdoodle'
+      
+    end
+  end
+
+  describe '#has_<name>' do
+    
+    it 'should return true when we have a member of name' do
+      blobject.modify {name 'barry'}
+      blobject.should have_name
+    end
+    
+    it 'should return false otherwise' do
+      blobject.should_not have_name
+    end
+  end
+  
+  describe '#[]' do
+    it 'allows get via hash like dereferencing' do
+      blobject.modify {name 'rod'}
+      blobject[:name].should == 'rod'
+    end
+    
+    it 'nil should be returned for a key miss' do
+      blobject[:name].should == nil
+    end
+  end
+  
+  describe '#[]=' do
+    it 'should relay to send' do
+      blobject.should_receive(:send).with(:name, 'barry')
+      blobject[:name] = 'barry'
+    end
+  end
+
+  describe '#merge' do
+    let(:data) do
+      { :one => 1,
+        :rest => [2,3,4,5,6,{:number => 7},8,9,0],
+        :nested => {
+          :structure => 'of values'
+        } }
+    end
+    
+    it 'should return self' do
+      blobject.merge({}).should equal blobject
+    end
+    
+    it 'should populate itself with the hash' do
+      blobject.merge data
+
+      blobject.one.should == 1
+      blobject.rest[5].should be_instance_of(Blobject)
+      blobject.rest[5].number.should == 7
+      blobject.nested.structure.should == 'of values'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$:.push File.expand_path('../lib', __FILE__)
+  
+require 'rspec'
+require 'ruby-debug'
+
+RSpec.configure do |config|  
+  
+end
+
+module SpecHelper
+
+end

data/test.rb

@@ -0,0 +1,6 @@
+class Myobject < Blobject
+  allow :name
+  
+
+end
+  

metadata

@@ -1,89 +1,84 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: blobject
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.1.9
   prerelease: 
-  version: 0.1.5
 platform: ruby
-authors: 
+authors:
 - Sam Taylor
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-14 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: wirble
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2011-09-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156185800 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: shoulda
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2156185800
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &2156182880 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-  type: :runtime
-  version_requirements: *id002
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156182880
 description: Blobject provides a free flowing syntax for creating blobs of data.
-email: 
+email:
 - sjltaylor@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .pryrc
+- .rspec
 - Gemfile
 - README.markdown
 - Rakefile
+- TODO.txt
 - blobject.gemspec
 - blobject.png
 - blobject.psd
 - lib/blobject.rb
 - lib/blobject/version.rb
-- test/helper.rb
-- test/test_blobject.rb
-has_rdoc: true
+- spec/blobject_spec.rb
+- spec/spec_helper.rb
+- test.rb
 homepage: https://github.com/sjltaylor/blobject
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: blobject
-rubygems_version: 1.5.0
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: serializable object builder
-test_files: 
-- test/helper.rb
-- test/test_blobject.rb
+test_files:
+- spec/blobject_spec.rb
+- spec/spec_helper.rb

data/test/helper.rb

@@ -1,19 +0,0 @@
-require 'rubygems'
-require 'bundler'
-
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'blobject'
-
-class Test::Unit::TestCase
-end

data/test/test_blobject.rb

@@ -1,45 +0,0 @@
-require 'helper'
-
-class TestBlobject < Test::Unit::TestCase
-  should "not be empty? if the blobject has data" do
-    b = Blobject.new
-    b.data = 'LOOK! some data. :)'
-    assert !b.empty?
-  end
-  
-  should "not be empty if the blobject complex with real data" do
-    b = Blobject.new
-    b.colors.red = '#ff0000'
-    assert !b.empty?
-  end
-  
-  should 'report empty when there are no descendants' do
-    assert Blobject.new.empty?
-  end
-  
-  should 'report empty? as true when descendants are empty Hash, Array or Blobjects' do
-    b = Blobject.new
-    b.array = []
-    b.hash = {}
-    b.blobject = Blobject.new
-    assert b.empty?
-  end
-  
-  should 'report empty? as false when descendants include a non-empty Array' do
-    b = Blobject.new
-    b.array = [1,2,3,4,5]
-    assert !b.empty?
-  end
-  
-  should 'report empty? as false when descendants include a non-empty Hash' do
-    b = Blobject.new
-    b.hash = {:key1 => 1, :key2 =>2, :key3 => 3}
-    assert !b.empty?
-  end
-  
-  should 'report empty? as false when descendants include a non-empty Blobject' do
-    b = Blobject.new
-    b.blobject = Blobject.new :initial_data => [1,2,3]
-    assert !b.empty?
-  end
-end