pottery 0.1.0

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1.0. initial release

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2008 Rob McKinnon
+
+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 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/Manifest

@@ -0,0 +1,8 @@
+CHANGELOG
+lib/pottery.rb
+LICENSE
+README
+spec/pottery_spec.rb
+spec/pottery_spec_helper.rb
+spec/spec.opts
+Manifest

data/README

@@ -0,0 +1,61 @@
+Pottery allows you to emerge class definitions via calling assignment methods and
+persist instances to a database; requires Morph and Soup gems.
+
+[Note API subject to change]
+
+== Pottery example
+
+Here's example code showing Pottery playing with Hpricot:
+
+> sqlite3 soup.db
+
+> irb
+
+ require 'pottery'
+ require 'hpricot'; require 'open-uri'
+
+ class Hubbit
+   include Pottery
+
+   def initialize name=nil
+     if name
+       doc = Hpricot open("http://github.com/#{name}")
+
+       (doc/'label').collect do |node|
+         label = node.inner_text
+         value = node.next_sibling.inner_text.strip
+
+         morph(label, value)
+       end
+       morph(:id_name, name)
+     end
+   end
+ end
+
+
+The model emerges from the data. Let's start by looking up 'why':
+
+ why = Hubbit.new 'why'
+
+What new methods do we have?
+
+ Hubbit.morph_methods # => ["email", "email=", "name", "name="]
+
+Ah-ha, so we have a name attribute now:
+
+ why.name #=> "why the lucky stiff"
+
+
+Let's save why for later
+
+ why.save
+
+
+Ok, now it's later, let's restore why from the database
+
+ why = Hubbit.restore('why') #=> <Hubbit @id_name="why", @name="why the lucky stiff", @email="why@why...">
+
+
+
+See LICENSE for the terms of this software.
+

data/lib/pottery.rb

@@ -0,0 +1,101 @@
+require 'morph'
+require 'soup'
+
+module Pottery
+  VERSION = "0.1.0"
+
+  def self.included(base)
+    Soup.prepare
+    base.extend Pottery::ClassMethods, Morph::ClassMethods
+    base.send(:include, Morph::InstanceMethods)
+    base.send(:include, Morph::MethodMissing)
+    base.send(:include, InstanceMethods)
+  end
+
+  class PotterySnip < Snip
+    def set_value(name, value); super; end
+  end
+
+  module ClassMethods
+    def restore name
+      snip = Pottery::PotterySnip[name]
+      if snip
+        instance = self.new
+        attributes = snip.attributes
+        unless attributes.empty?
+          id_name = attributes.delete('name')
+          name = attributes.delete('name_name')
+          attributes['id_name'] = id_name if id_name
+          attributes['name'] = name if name
+          instance.morph attributes
+        end
+        instance
+      else
+        nil
+      end
+    end
+  end
+
+  module InstanceMethods
+
+    def save
+      if respond_to?('id_name') && !id_name.nil? && !(id_name.to_s.strip.size == 0)
+        snip = Pottery::PotterySnip.new
+        morph_attributes.each_pair do |symbol, value|
+          symbol = convert_if_name_or_id_name(symbol)
+          snip.set_value(symbol.to_s, value)
+        end
+        snip.save
+        self
+      else
+        raise 'unique id_name must be defined'
+      end
+    end
+
+    private
+
+    def convert_if_name_or_id_name(symbol)
+      case symbol
+        when :id_name
+          :name
+        when :name
+          :name_name
+        else
+          symbol
+      end
+    end
+=begin
+    def method_missing symbol, *args
+      is_writer = symbol.to_s =~ /=\Z/
+      if is_writer
+        morph_method_missing symbol, *args do |base, attribute|
+          # alternative 1:
+          # base.class_eval "def #{attribute}; @snip.get_value('#{attribute}') ; end"
+          # base.class_eval "def #{attribute}= value; @snip ||= Pottery::PotterySnip.new; @snip.set_value('#{attribute}', value) ; end"
+
+          # alternative 2:
+          # base.class_eval { define_method(attribute) { @snip.get_value(attribute) } }
+          # base.class_eval do
+            # define_method("#{attribute}=") do |value|
+              # @snip ||= Pottery::PotterySnip.new
+              # @snip.set_value(attribute, value)
+            # end
+          # end
+
+          # alternative 3:
+          base.class_def(attribute) do
+            @snip.get_value(attribute)
+          end
+          base.class_def("#{attribute}=") do |value|
+            @snip ||= Pottery::PotterySnip.new
+            @snip.set_value(attribute, value)
+          end
+        end
+        send(symbol, *args)
+      else
+        super
+      end
+    end
+=end
+  end
+end

data/pottery.gemspec

@@ -0,0 +1,57 @@
+
+# Gem::Specification for Pottery-0.1.0
+# Originally generated by Echoe
+
+Gem::Specification.new do |s|
+  s.name = %q{pottery}
+  s.version = "0.1.0"
+
+  s.specification_version = 2 if s.respond_to? :specification_version=
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rob McKinnon"]
+  s.date = %q{2008-04-14}
+  s.description = %q{Pottery allows you to emerge class definitions via calling assignment methods and}
+  s.email = ["rob ~@nospam@~ rubyforge.org"]
+  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "lib/pottery.rb", "LICENSE", "README", "spec/pottery_spec.rb", "spec/pottery_spec_helper.rb", "spec/spec.opts", "Manifest", "pottery.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Pottery", "--main", "README", "--inline-source"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{pottery}
+  s.rubygems_version = %q{1.1.0}
+  s.summary = %q{Pottery allows you to emerge class definitions via calling assignment methods and}
+
+  s.add_dependency(%q<soup>, ["= 0.1.5"])
+  s.add_dependency(%q<morph>, [">= 0.1.5"])
+end
+
+
+# # Original Rakefile source (requires the Echoe gem):
+# 
+# require 'rubygems'
+# require 'spec'
+# require 'lib/pottery'
+# 
+# begin
+#   require 'echoe'
+# 
+#   Echoe.new("pottery", Pottery::VERSION) do |m|
+#     m.author = ["Rob McKinnon"]
+#     m.email = ["rob ~@nospam@~ rubyforge.org"]
+#     m.description = File.readlines("README").first
+#     m.rubyforge_name = "pottery"
+#     m.rdoc_options << '--inline-source'
+#     m.rdoc_pattern = ["README", "CHANGELOG", "LICENSE"]
+#     m.dependencies = ["soup =0.1.5", "morph >=0.1.5"]
+#   end
+# 
+# rescue LoadError
+#   puts "You need to install the echoe gem to perform meta operations on this gem"
+# end
+# 
+# desc "Open an irb session preloaded with this library"
+# task :console do
+#   sh "irb -rubygems -r ./lib/pottery.rb"
+# end

data/spec/pottery_spec.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/../lib/pottery'
+require File.dirname(__FILE__) + '/pottery_spec_helper'
+
+describe Pottery, "when writer method that didn't exist before is called with non-nil value" do
+  include PotterySpecHelperMethods
+
+  before :each do
+    remove_morph_methods
+    @quack = 'quack'
+    @pottery.noise= @quack
+    @attribute = 'noise'
+    @expected_morph_methods_count = 2
+  end
+
+  it_should_behave_like "class with generated accessor methods added"
+
+  it 'should return assigned value when reader method called' do
+    @pottery.noise.should == @quack
+  end
+end
+
+describe Pottery, "when pottery class is loaded" do
+  include PotterySpecHelperMethods
+
+  it 'should call Soup.prepare to setup database' do
+    Soup.should_receive(:prepare)
+    initialize_pottery_class
+  end
+
+  it 'should add restore class method' do
+    initialize_pottery_class
+    @potted_class.respond_to?('restore').should be_true
+  end
+end
+
+describe Pottery, "when reader method that doesn't exist is called" do
+  include PotterySpecHelperMethods
+
+  it 'should set attribute and value on the Snip instance' do
+    initialize_pottery_and_snip
+    lambda { @pottery.noise }.should raise_error(/undefined method `noise'/)
+  end
+end
+
+
+describe Pottery, "when save method is called after id_name has been set" do
+  include PotterySpecHelperMethods
+
+  after :each do remove_morph_methods; end
+
+  it 'should call save on the Snip instance' do
+    initialize_pottery_and_snip
+    @pottery.id_name = 'red'
+    @snip.should_receive(:save)
+    @pottery.save
+  end
+
+  it 'should call set_value on the Snip instance with attribute and value' do
+    initialize_pottery_and_snip
+    @pottery.id_name = 'red'
+
+    @snip.stub!(:save)
+    @snip.should_receive(:set_value).with('name', 'red')
+    @pottery.save
+  end
+end
+
+
+describe Pottery, "when save method is called after name and id_name has been set" do
+  include PotterySpecHelperMethods
+
+  after :each do remove_morph_methods; end
+
+  it 'should call save on the Snip instance' do
+    initialize_pottery_and_snip
+    @pottery.id_name = 'red'
+    @pottery.name = 'blue'
+    @snip.should_receive(:save)
+    @pottery.save
+  end
+
+  it 'should call set_value on the Snip instance with attribute and value' do
+    initialize_pottery_and_snip
+    @pottery.id_name = 'red'
+    @pottery.name = 'blue'
+
+    @snip.stub!(:save)
+    @snip.should_receive(:set_value).with('name', 'red')
+    @snip.should_receive(:set_value).with('name_name', 'blue')
+    @pottery.save
+  end
+end
+
+
+describe Pottery, "when save method is called after id_name has not been set" do
+  include PotterySpecHelperMethods
+
+  after :all do remove_morph_methods; end
+
+  it 'should call save on the Snip instance' do
+    initialize_pottery_and_snip
+    @pottery.colour = 'red'
+    lambda { @pottery.save }.should raise_error(/unique id_name must be defined/)
+  end
+end
+
+describe Pottery, "when restore method is called with name on class" do
+  include PotterySpecHelperMethods
+
+  before :each do
+    initialize_pottery_and_snip
+    @snip = mock(Pottery::PotterySnip)
+    @snip.stub!(:attributes).and_return({})
+    Pottery::PotterySnip.stub!('[]'.to_sym).and_return @snip
+  end
+
+  it 'should call Snip [] load method with given name' do
+    name = 'red'
+    Pottery::PotterySnip.should_receive('[]'.to_sym).with(name).and_return nil
+    @potted_class.restore(name)
+  end
+
+  it 'should return an instance of the class if Snip [] returns not nil' do
+    @potted_class.restore('red').should be_an_instance_of(@potted_class)
+  end
+
+  it 'should return nil if Snip [] returns nil' do
+    Pottery::PotterySnip.stub!('[]'.to_sym).and_return nil
+    @potted_class.restore('red').should be_nil
+  end
+
+  it 'should set attributes from snip on to class instance and return instance' do
+    attributes = {:name => 'red', :state => 'blue'}
+
+    @snip.stub!(:attributes).and_return(attributes)
+    Pottery::PotterySnip.stub!('[]'.to_sym).and_return @snip
+    instance = mock(@potted_class)
+    @potted_class.stub!(:new).and_return instance
+
+    instance.should_receive(:morph).with(attributes)
+    @potted_class.restore('red').should == instance
+  end
+
+end
+

data/spec/pottery_spec_helper.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/../lib/pottery'
+
+module PotterySpecHelperMethods
+
+  def initialize_pottery_class
+    @potted_class = eval 'class ExamplePottery; include Pottery; end'
+  end
+
+  def initialize_pottery
+    Soup.stub!(:prepare)
+    initialize_pottery_class
+    @original_instance_methods = @potted_class.instance_methods
+    @pottery = @potted_class.new
+  end
+
+  def initialize_snip
+    @snip = mock(Snip)
+    @snip.stub!(:set_value)
+    Pottery::PotterySnip.stub!(:new).and_return @snip
+  end
+
+  def initialize_pottery_and_snip
+    initialize_pottery
+    initialize_snip
+  end
+
+  def remove_morph_methods
+    @potted_class.instance_methods.each do |method|
+      @potted_class.class_eval "remove_method :#{method}" unless @original_instance_methods.include?(method)
+    end
+  end
+
+  def instance_methods
+    @potted_class.instance_methods
+  end
+
+  def morph_methods
+    @potted_class.morph_methods
+  end
+
+  def check_convert_to_pottery_method_name label, method_name
+    initialize_pottery_class
+    @potted_class.convert_to_pottery_method_name(label).should == method_name
+  end
+
+  def each_attribute
+    if @attribute
+      yield @attribute
+    elsif @attributes
+      @attributes.each {|a| yield a }
+    end
+  end
+end
+
+describe "class with generated accessor methods added", :shared => true do
+  include PotterySpecHelperMethods
+
+  before :all do initialize_pottery; end
+  after  :all do remove_morph_methods; end
+
+  it 'should add reader method to class instance_methods list' do
+    each_attribute { |a| instance_methods.should include(a.to_s) }
+  end
+
+  it 'should add writer method to class instance_methods list' do
+    each_attribute { |a| instance_methods.should include("#{a}=") }
+  end
+
+  it 'should add reader method to class morph_methods list' do
+    each_attribute { |a| morph_methods.should include(a.to_s) }
+  end
+
+  it 'should add writer method to class morph_methods list' do
+    each_attribute { |a| morph_methods.should include("#{a}=") }
+  end
+
+  it 'should only have generated accessor methods in morph_methods list' do
+    morph_methods.size.should == @expected_morph_methods_count
+  end
+
+end
+
+describe "class without generated accessor methods added", :shared => true do
+  include PotterySpecHelperMethods
+
+  before :all do initialize_pottery; end
+  after :all do remove_morph_methods; end
+
+  it 'should not add reader method to class instance_methods list' do
+    instance_methods.should_not include(@attribute)
+  end
+
+  it 'should not add writer method to class instance_methods list' do
+    instance_methods.should_not include("#{@attribute}=")
+  end
+
+  it 'should not add reader method to class morph_methods list' do
+    morph_methods.should_not include(@attribute)
+  end
+
+  it 'should not add writer method to class morph_methods list' do
+    morph_methods.should_not include("#{@attribute}=")
+  end
+
+  it 'should have empty morph_methods list' do
+    morph_methods.size.should == 0
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse
+--backtrace

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: pottery
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rob McKinnon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-14 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: soup
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.1.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: morph
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.5
+    version: 
+description: Pottery allows you to emerge class definitions via calling assignment methods and
+email: 
+- rob ~@nospam@~ rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- LICENSE
+- README
+files: 
+- CHANGELOG
+- lib/pottery.rb
+- LICENSE
+- README
+- spec/pottery_spec.rb
+- spec/pottery_spec_helper.rb
+- spec/spec.opts
+- Manifest
+- pottery.gemspec
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Pottery
+- --main
+- README
+- --inline-source
+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: pottery
+rubygems_version: 1.1.0
+signing_key: 
+specification_version: 2
+summary: Pottery allows you to emerge class definitions via calling assignment methods and
+test_files: []
+