cobble 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 markbates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,76 @@
+=Cobble
+
+A very simple and easy library to help facilitate the building and creating of objects. They can be any type of objects, although if you want to 'persist' them they need to respond to <code>.save!</code>. Cobble is there to put YOU in charge of how your objects get created. There's very little magic, it's just there to help make your life a little bit easier.
+
+==Examples:
+
+===Defining Attributes:
+
+Attributes can be defined to be used later in your cobblers, or they can be used on their own for other use.
+
+  Cobble.define_attributes(:user, :name => 'Mark Bates')
+  Cobble.define_attributes(:another_user, :attributes_for => :user, :email => lambda{fake(:email)})
+  Cobble.define_attributes(:yet_another_user, :attributes_for => :user, :email => lambda{rand})
+  
+  # Test:
+  Cobble.attributes_for(:user).should == {:name => 'Mark Bates'}
+  Cobble.attributes_for(:another_user).should == {:name => 'Mark Bates', :email => 'bob@example.com'}
+  Cobble.attributes_for(:yet_another_user).should == {:name => 'Mark Bates', :email => 0.123456789}
+
+===Defining a Cobbler:
+
+A cobbler is what actually builds your object(s). A cobble is fully defined by you, Cobble just helps to give you the proper attributes and options for your object.
+
+  Cobble.define(:user) do
+    User.new(options)
+  end
+  Cobble.define(:another_user) do
+    user = User.new(options)
+    user.url = 'http://www.metabates.com'
+    user
+  end
+  Cobble.define(:yet_another_user) do
+    User.new(options)
+  end
+  
+  # Test
+  
+  # build and save:
+  user = Cobble.user # or Cobble.create(:user)
+  user.name.should == 'Mark Bates'
+  user.should_not be_new_record
+  
+  # just build:
+  user = Cobble.build_user # or Cobble.build(:user)
+  user.name.should == 'Mark Bates'
+  user.should be_new_record
+  
+  # build and save:
+  user = Cobble.another_user # or Cobble.create(:another_user)
+  user.name.should == 'Mark Bates'
+  user.email.should == 'bob@example.com'
+  user.url.should == 'http://www.metabates.com'
+  user.should_not be_new_record
+  
+  # just build:
+  user = Cobble.build_another_user # or Cobble.build(:another_user)
+  user.name.should == 'Mark Bates'
+  user.email.should == 'bob@example.com'
+  user.url.should == 'http://www.metabates.com'
+  user.should be_new_record
+  
+  # build and save:
+  user = Cobble.another_user(:name => 'Bob Smith') # or Cobble.create(:another_user)
+  user.name.should == 'Bob Smith'
+  user.email.should == 'bob@example.com'
+  user.url.should == 'http://www.metabates.com'
+  user.should_not be_new_record
+  
+  # just build:
+  user = Cobble.build_another_user(:name => 'Bob Smith') # or Cobble.build(:another_user)
+  user.name.should == 'Bob Smith'
+  user.email.should == 'bob@example.com'
+  user.url.should == 'http://www.metabates.com'
+  user.should be_new_record
+
+Cobblers will try and use a matching set of attributes, if defined, as the basis for the options available to your cobbler. You can, of course, pass in different options at runtime to override these defaults.

data/lib/cobble.rb

@@ -0,0 +1,15 @@
+require 'singleton'
+require 'faker'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'cobble', '**/*.rb')).each do |f|
+  require File.expand_path(f)
+end
+
+def Cobble(name, *args, &block)
+  Cobble.create(name, *args, &block)
+end
+
+def Factory(name, *args, &block)
+  puts "*** WARNING *** You should migrate over to using the proper Cobble methods as this won't be here forever!"
+  Cobble.create(name, *args, &block)
+end

data/lib/cobble/binding.rb

@@ -0,0 +1,72 @@
+class Cobble
+  class Binding
+    attr_accessor :name
+    attr_accessor :type
+    attr_accessor :options
+  
+    def initialize(name, options = {}) # :nodoc:
+      self.name = name
+      self.type = :build
+      self.options = {}
+      parse_options(options)
+
+      self.attributes_for(name)
+    
+      attr_for = self.options.delete(:attributes_for)
+      if attr_for
+        self.attributes_for(attr_for)
+      end
+    end
+  
+    def fake(name, *args)
+      Cobble::Fakes.execute(name.to_sym, *args)
+    end
+  
+    def execute(&block)
+      eval_options
+      instance_eval(&block)
+    end
+  
+    def attributes_for(names)
+      [names].flatten.each do |name|
+        self.options = Cobble.attribs(name).dup.merge(self.options)
+      end
+    end
+  
+    def method_missing(sym, *args, &block)
+      unless self.options[sym]
+        if block_given?
+          self.options[sym] = yield
+        end
+      end
+    end
+  
+    private
+    def parse_options(options)
+      case options
+      when Hash
+        self.options = options
+      when Array
+        if options.empty?
+          self.options = {}
+        else
+          options.each do |val|
+            if val.is_a?(Hash)
+              self.options = val
+              break
+            end
+          end
+        end
+      end
+    end
+  
+    def eval_options
+      self.options.each do |key, val|
+        if val.is_a?(Proc)
+          self.options[key] = instance_eval(&val)
+        end
+      end
+    end
+  
+  end # Binding
+end # Cobble

data/lib/cobble/cobble.rb

@@ -0,0 +1,87 @@
+class Cobble
+  include Singleton
+  
+  attr_accessor :factories
+  attr_accessor :attributes
+  
+  def initialize # :nodoc:
+    self.reset!
+  end
+  
+  def reset!
+    self.factories = {}
+    self.attributes = {}
+  end
+  
+  def define(factory_name, options = {}, &block)
+    self.factories[factory_name.to_sym] = [options, block]
+  end
+  
+  def define_attributes(name, options = {})
+    self.attributes[name.to_sym] = options
+  end
+  
+  def attribs(name)
+    self.attributes[name.to_sym] || {}
+  end
+  
+  def build(factory, *args, &block)
+    return execute(factory.to_sym, :build, *args)
+  end
+  
+  def create(factory, *args, &block)
+    res = self.execute(factory.to_sym, :create, *args)
+    res.save!
+    return res
+  end
+  
+  def attributes_for(factory, *args, &block)
+    fb = self.cobble_binding(factory.to_sym, :build, *args)
+    fb.execute {}
+    return fb.options
+  end
+  
+  def method_missing(sym, *args, &block)
+    meth = sym.to_s
+    case meth
+    when /^build_(.+)$/
+      return self.build($1, *args, &block)
+    when /^attributes_for_(.+)$/
+      return self.attributes_for($1, *args, &block)
+    when /^create_(.+)$/
+      return self.create($1, *args, &block)
+    else
+      return self.create(sym, *args, &block)
+    end
+  end
+  
+  class << self
+    
+    def method_missing(sym, *args, &block)
+      Cobble.instance.send(sym, *args, &block)
+    end
+    
+  end
+  
+  protected
+  def cobble_binding(name, type, *args)
+    factory = self.factories[name.to_sym]
+    raise ArgumentError.new("No Factory defined for '#{name}'!!!") if factory.nil?
+    
+    fb = Cobble::Binding.new(name.to_sym, *args)
+    fb.type = type
+    options = (factory[0] || {}).dup
+    attr_for = options.delete(:attributes_for)
+    if attr_for
+      fb.attributes_for(attr_for)
+    end
+    return fb
+  end
+  
+  def execute(name, type, *args)
+    factory = self.factories[name.to_sym]
+    fb = cobble_binding(name, type, *args)
+    return fb.execute(&factory[1])
+  end
+  
+end

data/lib/cobble/errors.rb

@@ -0,0 +1,11 @@
+class Cobble
+  module Errors # :nodoc:
+    class NoFakeRegistered < StandardError
+      
+      def initialize(name) # :nodoc:
+        super("No fake has been registered for '#{name}'!")
+      end
+      
+    end # NoFakeRegistered
+  end # Errors
+end # Cobble

data/lib/cobble/fakes.rb

@@ -0,0 +1,82 @@
+class Cobble
+  class Fakes
+    include Singleton
+  
+    attr_accessor :list
+  
+    def initialize
+      self.reset!
+    end
+  
+    def reset!
+      self.list = {}
+    end
+  
+    def add(name, &block)
+      self.list[name.to_sym] = block
+    end
+  
+    def alias(from, to)
+      self.list[from.to_sym] = Cobble::Fakes::Alias.new(to)
+    end
+  
+    def execute(name, *args)
+      block = self.list[name.to_sym]
+      if block.is_a?(Cobble::Fakes::Alias)
+        return execute(block.to, *args)
+      end
+      if block
+        return block.call(*args)
+      end
+      raise Cobble::Errors::NoFakeRegistered.new(name)
+    end
+  
+    class << self
+      def method_missing(sym, *args, &block)
+        Cobble::Fakes.instance.send(sym, *args, &block)
+      end
+    end # class << self
+  
+    private
+    class Alias
+      attr_accessor :to
+      def initialize(to)
+        self.to = to
+      end
+    end
+    
+  end # Fakes
+end # Cobble
+
+%w{first_name last_name name prefix suffix}.each do |m|
+  eval("Cobble::Fakes.add(:#{m}) {|*args| Faker::Name.#{m}(*args)}")
+end
+
+%w{city city_prefix city_suffix secondary_address street_address street_name 
+   street_suffix uk_country uk_county uk_postcode us_state us_state_abbr zip_code}.each do |m|
+  eval("Cobble::Fakes.add(:#{m}) {|*args| Faker::Address.#{m}(*args)}")
+end
+
+%w{bs catch_phrase name suffix}.each do |m|
+  eval("Cobble::Fakes.add(:#{m}) {|*args| Faker::Company.#{m}(*args)}")
+end
+
+%w{domain_name domain_suffix domain_word email free_email user_name}.each do |m|
+  eval("Cobble::Fakes.add(:#{m}) {|*args| Faker::Internet.#{m}(*args)}")
+end
+
+%w{paragraph paragraphs sentence sentences words}.each do |m|
+  eval("Cobble::Fakes.add(:#{m}) {|*args| Faker::Lorem.#{m}(*args)}")
+end
+
+%w{phone_number}.each do |m|
+  eval("Cobble::Fakes.add(:#{m}) {|*args| Faker::PhoneNumber.#{m}(*args)}")
+end
+
+Cobble::Fakes.add(:url) {|*args| 'http://' + Faker::Internet.domain_name(*args)}
+Cobble::Fakes.add(:lorem) {|*args| Faker::Lorem.paragraphs(*args).join("\n")}
+Cobble::Fakes.add(:name) {|*args| Faker::Name.first_name + ' ' + Faker::Name.last_name}
+Cobble::Fakes.add(:birth_date) {|*args| (rand(80) + 13).years.ago}
+Cobble::Fakes.add(:title) {|*args| Faker::Company.catch_phrase.slice(0..250)}
+Cobble::Fakes.alias(:body, :lorem)
+Cobble::Fakes.alias(:full_name, :name)

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: cobble
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- markbates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-15 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: faker
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "cobble was developed by: markbates"
+email: development@metabates.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- lib/cobble/binding.rb
+- lib/cobble/cobble.rb
+- lib/cobble/errors.rb
+- lib/cobble/fakes.rb
+- lib/cobble.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: http://www.metabates.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: magrathea
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: cobble
+test_files: []
+