catwalk 0.0.1

data/.autotest

@@ -0,0 +1,17 @@
+begin
+  require 'autotest/fsevent'
+rescue LoadError
+end
+
+Autotest.add_hook :initialize do |at|
+
+  at.add_exception /^(?:\.\/)?\.git/
+  at.add_exception /^(?:\.\/)?\.bundle/
+  at.add_exception /^(?:\.\/)?tmp/
+
+  at.add_mapping(/^.autotest$/,true) { |_,_|
+    Dir["spec/**/*_spec.rb"]
+  }
+
+  nil
+end

data/.gitignore

@@ -0,0 +1,5 @@
+.rvmrc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in catwalk.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/catwalk.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "catwalk/version"
+
+Gem::Specification.new do |s|
+  s.name        = "catwalk"
+  s.version     = Catwalk::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jon Rowe"]
+  s.email       = ["hello@jonrowe.co.uk"]
+  s.homepage    = "http://github.com/jonrowe/catwalk"
+  s.summary     = %q{Catwalk is a gem for showing off models. It allows you to seperate presentation logic from data models.}
+  s.description = %q{Catwalk is a gem for showing off models. It allows you to seperate presentation logic from data models.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/* .autotest`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'ruby-debug19'
+  s.add_development_dependency 'autotest-standalone'
+  s.add_development_dependency 'autotest-fsevent' if RUBY_PLATFORM =~ /darwin/
+
+  s.add_development_dependency 'activemodel'
+end

data/cucumber.yml

@@ -0,0 +1,3 @@
+default: --color --format pretty features
+autotest: --color --format pretty features
+autotest-all: --color --format pretty features

data/features/active_model_compatibility.feature

@@ -0,0 +1,11 @@
+Feature: Active Model compatibility
+  In order to use presenters interchangably with active models
+  As a developer
+  I wish to use catwalk to present my models whilst adhering to ActiveModel::Lint
+
+  Scenario: Basic Active Model functionality
+    Given I have an ActiveModel based model
+    And I have a presenter class
+    When I include Catwalk
+    And I setup my presenter to represent my model
+    Then my presenter should expose the models ActiveModel functionality

data/features/basic_fields.feature

@@ -0,0 +1,11 @@
+Feature: Presenting basic fields from an active model compatible model
+  In order to seperate my presentation logic from my persistance models
+  As a developer
+  I want to wrap my models in a catwalk presenter
+
+  Scenario: Basic usage
+    Given I have an ActiveModel based model
+    And my model has a attribute named "title"
+    And I have a Catwalk presenter class for my model
+    When I define a field "title"
+    Then my presenter should present "title" from my model

data/features/specifying_model_accessor.feature

@@ -0,0 +1,10 @@
+Feature: Specifying model accessor
+	In order to access the underlying model in my presenter methods
+	As a developer
+	I want to specify an accessor I will use to access the undelying model
+
+	Scenario: Specifiying accessor
+		Given I have an ActiveModel based model
+		And I have a Catwalk presenter class for my model
+		When I set access_as to "my_model"
+		Then my presenter should expose the model via "my_model"

data/features/step_definitions/model_steps.rb

@@ -0,0 +1,9 @@
+Given "I have an ActiveModel based model" do
+  @model = ActiveModelExample.new
+end
+
+Given /^my model has a attribute named "([^"]*)"$/ do |field_name|
+  @model.class.class_eval do
+    define_method(field_name) { "a value for checking later" }
+  end
+end

data/features/step_definitions/presenter_steps.rb

@@ -0,0 +1,46 @@
+Given "I have a presenter class" do
+  @presenter_klass = Class.new
+end
+
+Given "I have a Catwalk presenter class for my model" do
+  klass = Class.new
+  klass.send :include, Catwalk::Presenter
+  @presenter = klass.new @model
+end
+
+When "I include Catwalk" do
+  @presenter_klass.send :include, Catwalk::Presenter
+end
+
+When "I setup my presenter to represent my model" do
+  @presenter = @presenter_klass.new(@model)
+end
+
+When /^I define a field "([^"]*)"$/ do |field_name|
+  @presenter.class.class_eval do
+    field field_name
+  end
+end
+
+When /^I set access_as to "([^"]*)"$/ do |accessor|
+  @presenter.class.class_eval do
+    access_as accessor
+  end
+end
+
+Then "my presenter should expose the models ActiveModel functionality" do
+  @presenter.to_key.should == @model.to_key
+  @presenter.to_param.should == @model.to_param
+  @presenter.valid?.should == @model.valid?
+  @presenter.persisted?.should == @model.persisted?
+  @presenter.errors.should == @model.errors
+  @presenter.to_model.should == @model
+end
+
+Then /^my presenter should present "([^"]*)" from my model$/ do |field_name|
+  @presenter.send(field_name).should == @model.send(field_name)
+end
+
+Then /^my presenter should expose the model via "([^"]*)"$/ do |field_name|
+  @presenter.send(field_name).should == @model
+end

data/features/support/active_model_example.rb

@@ -0,0 +1,23 @@
+require 'active_model'
+
+class ActiveModelExample
+	extend ActiveModel::Naming
+
+	attr_reader :errors
+
+	def initialize
+		@errors = ActiveModel::Errors.new(self)
+	end
+
+	def to_model
+		self
+	end
+
+	def to_key; {}; end
+	def to_param; {}; end
+	def valid?;      true; end
+	def new_record?; true; end
+	def destroyed?;  true; end
+	def persisted?;  true; end
+end
+

data/features/support/env.rb

@@ -0,0 +1,2 @@
+require 'ruby-debug'
+require 'catwalk'

data/lib/catwalk.rb

@@ -0,0 +1 @@
+require 'catwalk/presenter'

data/lib/catwalk/presenter.rb

@@ -0,0 +1,35 @@
+module Catwalk
+  module Presenter
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    def initialize(model)
+      @model = model
+    end
+
+    define_method(:to_model)   { @model }
+    define_method(:to_param)   { @model.to_param if persisted? }
+    define_method(:to_key)     { @model.to_key   if persisted? }
+    define_method(:persisted?) { @model.persisted? }
+    define_method(:valid?)     { @model.valid? }
+    define_method(:model_name) { @model.model_name }
+    define_method(:errors)     { @model.errors }
+
+    module ClassMethods
+
+      def field(field_name)
+        define_method field_name do
+          @model.send field_name
+        end
+      end
+
+      def access_as(accessor)
+        define_method accessor do
+          @model
+        end
+      end
+
+    end
+  end
+end

data/lib/catwalk/version.rb

@@ -0,0 +1,3 @@
+module Catwalk
+  VERSION = "0.0.1"
+end

data/spec/catwalk/presenter_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Catwalk
+  describe Presenter do
+
+    let(:model) { mock "model" }
+    let(:klass) { Class.new }
+    let(:presenter) { klass.new(model) }
+
+    before do
+      klass.class_eval { include Catwalk::Presenter }
+    end
+
+    describe "initialization" do
+      subject { presenter }
+
+      it "should assign an the model to an instance variable accessible via to_model" do
+        subject.to_model.should == model
+      end
+    end
+
+    describe "active model compliance" do
+      let(:model_name) { mock 'model_name', human: "Model Name", singular: "model_name", plural: "Model Names", partial_path: '/model' }
+      let(:active_model_errors) { mock "errors", full_messages: [], :[] => [] }
+      let(:model) { mock "model", to_key: {}, to_param: {}, valid?: true, persisted?: true, model_name: model_name, errors: active_model_errors }
+
+      before do
+        model_name.stub(:kind_of?).with(String).and_return(true)
+      end
+      subject { presenter }
+
+      it_should_behave_like "ActiveModel"
+      it_should_behave_like "proxy active_model method", :to_key,     from: :model
+      it_should_behave_like "proxy active_model method", :to_param,   from: :model
+      it_should_behave_like "proxy active_model method", :valid?,     from: :model
+      it_should_behave_like "proxy active_model method", :persisted?, from: :model
+      it_should_behave_like "proxy active_model method", :model_name, from: :model
+      it_should_behave_like "proxy active_model method", :errors,     from: :model
+      its(:to_model) { should == model }
+    end
+
+    describe "access_as" do
+      subject do
+        klass.class_eval do
+          access_as :model_accessor
+        end
+        presenter
+      end
+
+      its(:model_accessor) { should == model }
+    end
+
+    describe "field" do
+      let(:model_value) { "a value" }
+
+      before do
+        model.stub(:a_field).and_return(model_value)
+      end
+
+      subject do
+        klass.class_eval do
+          field :a_field
+        end
+        presenter.a_field
+      end
+
+      it "should proxy field to model" do
+        model.should_receive(:a_field).and_return(model_value)
+        subject
+      end
+      it { should == model_value }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'ruby-debug'
+
+require 'catwalk'
+
+Dir["./spec/support/**/*.rb"].each { |f| require f }

data/spec/support/active_model_lint.rb

@@ -0,0 +1,33 @@
+# spec/support/active_model_lint.rb
+# adapted from rspec-rails: http://github.com/rspec/rspec-rails/blob/master/spec/rspec/rails/mocks/mock_model_spec.rb
+
+shared_examples_for "ActiveModel" do
+
+  it { should respond_to :to_key }
+  it { should respond_to :to_param }
+  it { should respond_to :valid? }
+  it { should respond_to :persisted? }
+  it { should respond_to :model_name }
+  it { should respond_to :errors }
+  it { should respond_to :to_model }
+
+  its(:"model_name")              { should be_a String }
+  its(:"model_name.human")        { should be_a String }
+  its(:"model_name.partial_path") { should be_a String }
+  its(:"model_name.singular")     { should be_a String }
+  its(:"model_name.plural")       { should be_a String }
+
+  its(:"errors.full_messages") { should be_a Array }
+  it "should have blank arrays for keys" do
+    subject.errors[:hello].should == []
+  end
+
+  context "where not persisted" do
+    before do
+      subject.stub(:persisted?).and_return(false)
+    end
+
+    its(:to_key)   { should be_nil }
+    its(:to_param) { should be_nil }
+  end
+end

data/spec/support/active_model_proxy_shared_examples.rb

@@ -0,0 +1,17 @@
+shared_examples_for "proxy active_model method" do |method,opts|
+	let(:target) { send opts[:from] }
+	let(:target_value) { mock "value" }
+
+	before do
+		target.stub(method).and_return(target_value)
+	end
+
+	it "should proxy #{method} to #{opts[:from]}" do
+		target.should_receive(method).and_return(target_value)
+		subject.send(method)
+	end
+
+	it "#{method} should == #{opts[:from]}.value" do
+		subject.send(method).should == target_value
+	end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification 
+name: catwalk
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jon Rowe
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-23 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: autotest-standalone
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: autotest-fsevent
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Catwalk is a gem for showing off models. It allows you to seperate presentation logic from data models.
+email: 
+- hello@jonrowe.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- catwalk.gemspec
+- cucumber.yml
+- features/active_model_compatibility.feature
+- features/basic_fields.feature
+- features/specifying_model_accessor.feature
+- features/step_definitions/model_steps.rb
+- features/step_definitions/presenter_steps.rb
+- features/support/active_model_example.rb
+- features/support/env.rb
+- lib/catwalk.rb
+- lib/catwalk/presenter.rb
+- lib/catwalk/version.rb
+- spec/catwalk/presenter_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_model_lint.rb
+- spec/support/active_model_proxy_shared_examples.rb
+has_rdoc: true
+homepage: http://github.com/jonrowe/catwalk
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Catwalk is a gem for showing off models. It allows you to seperate presentation logic from data models.
+test_files: 
+- .autotest
+- features/active_model_compatibility.feature
+- features/basic_fields.feature
+- features/specifying_model_accessor.feature
+- features/step_definitions/model_steps.rb
+- features/step_definitions/presenter_steps.rb
+- features/support/active_model_example.rb
+- features/support/env.rb
+- spec/catwalk/presenter_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_model_lint.rb
+- spec/support/active_model_proxy_shared_examples.rb