neo-rails 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in neo-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+MIT License
+
+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.md

@@ -0,0 +1,66 @@
+# Neo::Rails
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'neo-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install neo-rails
+
+## Usage
+
+### Presenter
+
+In app/presenters/presenter.rb
+
+    class Presenter
+      include Neo::Rails::Presenter
+    end
+
+
+    class UserPresenter < Presenter
+      def initialize(user)
+        @user = user
+      end
+
+      def name
+        @user.name
+      end
+
+      def profile_path
+        view_context.link_to view_context.user_profile_path(@user), name
+      end
+    end
+
+In test/test_helper.rb
+
+    require 'neo/rails/presenter/test_helper'
+
+    Neo::Rails::Presenter::TestHelper.setup
+
+### Scenarios
+
+In app/assets/stylesheets/application.css:
+
+    //= require neo-rails
+
+In app/layouts/application.html.haml
+
+    = render_scenarios_list
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end

data/lib/assets/stylesheets/neo-rails.css

@@ -0,0 +1 @@
+//= require neo/rails/scenarios/render_scenarios_list

data/lib/assets/stylesheets/neo/rails/scenarios/render_scenarios_list.css.sass

@@ -0,0 +1,8 @@
+.neo-rails-scenarios-list
+  position: absolute
+  right: 0
+  top: 0
+  width: 250px
+  padding: 5px
+  background: #AAFFAA
+  border: 2px solid green

data/lib/neo-rails.rb

@@ -0,0 +1 @@
+require "neo/rails"

data/lib/neo/rails.rb

@@ -0,0 +1,11 @@
+module Neo
+  module Rails
+  end
+end
+
+require 'neo/rails/mock'
+require 'neo/rails/exposure'
+require 'neo/rails/scenarios'
+require 'neo/rails/presenter'
+
+require 'neo/rails/engine' if defined?(::Rails)

data/lib/neo/rails/engine.rb

@@ -0,0 +1,21 @@
+module Neo
+  module Rails
+    class Engine < ::Rails::Engine
+      initializer "neo-rails.scenarios_helpers" do
+        require 'neo/rails/scenarios/rails_helper'
+
+        ActiveSupport.on_load(:action_view) do
+          include Neo::Rails::Scenarios::RailsHelper
+        end
+      end
+
+      initializer "neo-rails.presenter_method" do
+        ActiveSupport.on_load(:action_controller) do
+          before_filter do |controller|
+            Neo::Rails::Presenter.view_context = controller.view_context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/exposure.rb

@@ -0,0 +1,47 @@
+module Neo
+  module Rails
+    # A really simple version of exposing variables to the view.
+    # Bases on attr_reader and helper_method.
+    module Exposure
+      extend ActiveSupport::Concern
+
+      class UndeclaredVariableError < StandardError; end
+
+      included do
+        class_attribute :exposed_vars
+        self.exposed_vars = Set.new
+      end
+
+      module ClassMethods
+        # Defines the variables to be exposed.
+        def exposes(*names)
+          exposures = names.map(&:to_sym).reject { |name| exposed_vars.include?(name) }
+          self.exposed_vars.merge exposures
+          attr_reader *exposures
+          helper_method *exposures
+        end
+      end
+
+      # Expose an assign at the instance level.
+      #
+      # If the value is given with a block, just execute the block
+      # if a value was not set yet.
+      #
+      # Raise UndeclaredVariableError if access variable wasn't declared before.
+      def expose(key, value=nil)
+        name = key.to_sym
+        raise UndeclaredVariableError unless self.class.exposed_vars.include?(name)
+
+        value = yield if block_given?
+
+        self.instance_variable_set("@#{name}", value)
+      end
+
+      private
+
+      def exposed?(name)
+        instance_variable_get("@#{name}")
+      end
+    end
+  end
+end

data/lib/neo/rails/mock.rb

@@ -0,0 +1,67 @@
+require 'set'
+
+# A Mock can fake an object.
+#
+# This is useful when frontend developers want to fill a page with
+# mock data. Mocks can pre-define interface for real data.
+# 
+# == Usage
+#
+# app/mocks/user_mock.rb:
+#
+#   class UserMock < Neo::Rails::Mock
+#     def age
+#       mock.tagged?(:old) ? 78 : 23
+#     end
+#
+#     def name
+#       "Uncle bob"
+#     end
+#
+#     def logged_in?
+#       true
+#     end
+#
+#     def sexy?
+#       mock.tagged?(:sexy)
+#     end
+#   end
+#
+# Further...
+#
+#   old_man = UserMock.new(:old)
+#   old_man.age # => 78
+#   old_man.name # => "Uncle Bob"
+#
+#   old_sexbomb = UserMock.new(:old, :sexy)
+#   old_sexbomb.age # => 78
+#   old_sexbomb.sexy? # => true
+#
+module Neo
+  module Rails
+    class Mock
+      attr_reader :mock
+
+      # Initializes a Mock with optional tag list.
+      def initialize(*args)
+        @mock = MockConfig.new(args)
+      end
+
+      class MockConfig
+        def initialize(args)
+          @tags = args
+        end
+
+        # Returns a human readable tag list.
+        def description
+          @tags.to_a.map { |tag| tag.to_s.capitalize }.join(", ")
+        end
+
+        # Checks if this mock is tagged with +tag+.
+        def tagged?(tag)
+          @tags.include?(tag)
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/presenter.rb

@@ -0,0 +1,23 @@
+module Neo
+  module Rails
+    module Presenter
+      def self.included(base)
+        base.class_eval do
+          def view_context
+            Neo::Rails::Presenter.view_context
+          end
+        end
+      end
+
+      class << self
+        def view_context
+          Thread.current[:neo_rails_presenter_view_context]
+        end
+
+        def view_context=(view_context)
+          Thread.current[:neo_rails_presenter_view_context] = view_context
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/presenter/test_helper.rb

@@ -0,0 +1,23 @@
+module Neo
+  module Rails
+    module Presenter
+      module TestHelper
+        def setup
+          Presenter.view_context = FakeViewContext.instance
+        end
+        module_function :setup
+
+        class FakeViewContext
+          include Singleton
+          include ActionView::Helpers::TagHelper
+          include ActionView::Helpers::UrlHelper
+          include Sprockets::Helpers::RailsHelper
+          include Sprockets::Helpers::IsolatedHelper
+          include ::Rails.application.routes.url_helpers
+
+          attr_accessor :output_buffer
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/scenarios.rb

@@ -0,0 +1,111 @@
+module Neo
+  module Rails
+    # Enables controller actions to have scenarios, which will be applied
+    # +before+ the execution of the action.
+    module Scenarios
+      extend ActiveSupport::Concern
+
+      class DuplicatedScenario < StandardError; end
+      class ExposureMustBeIncludedFirst < StandardError; end
+
+      included do
+        if self < Neo::Rails::Exposure
+          class_attribute :scenarios
+          self.scenarios = Hash.new { |hash, action| hash[action] = {} }
+          before_filter :apply_scenario
+          helper_method :list_scenarios
+        else
+          raise ExposureMustBeIncludedFirst
+        end
+      end
+
+      module ClassMethods
+        # Defines a scenario
+        #
+        # == Usage
+        #
+        #   class AController < ActionController::Base
+        #     include Neo::Rails::Exposure
+        #     include Neo::Rails::Scenarios
+        #
+        #     exposes :foo
+        #
+        #     def show
+        #       ...
+        #     end
+        #
+        #     scenario :show, :a_scenario do
+        #       expose :foo, "bar" # any expose calls on :foo will be ignored in the action
+        #     end
+        #   end
+        #
+        # Raises DuplicatedScenario if there is already a scenario for the action with the same name
+        #
+        def scenario(action, name, options={}, &block)
+          scenario = Scenario.new(action, name, block, options)
+
+          raise DuplicatedScenario if self.scenarios[scenario.action][scenario.name]
+
+          self.scenarios[scenario.action][scenario.name] = scenario
+        end
+
+        def list_scenarios
+          self.scenarios.values.map(&:values).flatten
+        end
+      end
+
+      # Overwrites expose so it will only set the value once.
+      # see Neo::Rails::Exposure
+      def expose(name, value=nil)
+        if exposed?(name)
+          # nothing as set already via mock
+        else
+          super
+        end
+      end
+
+      # List all defined scenarios
+      #
+      # Return an Array of +scenario+ objects
+      def list_scenarios
+        self.class.list_scenarios
+      end
+
+    protected
+
+      # Applies a scenario as a before filter if there is one which fits.
+      def apply_scenario
+        action_key   = params[:action].to_sym
+        scenario_key = params[:scenario].try(:to_sym)
+        if scenario_key && (scenario = self.class.scenarios[action_key][scenario_key])
+          instance_eval(&scenario.block)
+        end
+      end
+
+      # Does this controller run a scenario right now?
+      def scenario?
+        params[:scenario]
+      end
+
+      # A simple class encapsulating a scenario:
+      # * the corresponding action
+      # * the scenario's name
+      # * an humanized name as label
+      # * the blocked which will be called when applying a scenario
+      class Scenario
+        attr_reader :action, :name, :block, :options
+
+        def initialize(action, name, block, options)
+          @action   = action.to_sym
+          @name     = name.to_sym
+          @block    = block
+          @options  = options
+        end
+
+        def label
+          "#{@action.to_s.humanize} -> #{@name.to_s.humanize}"
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/scenarios/rails_helper.rb

@@ -0,0 +1,19 @@
+module Neo
+  module Rails
+    module Scenarios
+      module RailsHelper
+        def scenario_link(scenario)
+          link_to scenario.label, url_for(:action => scenario.action, :scenario => scenario.name, :id => 1), scenario.options
+        end
+
+        def render_scenarios_list
+          if ::Rails.env.development? && respond_to?(:list_scenarios) && (list = list_scenarios).any?
+            scenario_links = list.map { |scenario| content_tag(:li, scenario_link(scenario)) }
+            ul = content_tag(:ul, scenario_links.join.html_safe)
+            raw content_tag(:div, ul, :class => "neo-rails-scenarios-list")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/scenarios/test_helper.rb

@@ -0,0 +1,48 @@
+module Neo
+  module Rails
+    module Scenarios
+      # Useful test helpers for minitest (test/unit).
+      #
+      # == Usage
+      #
+      #   require 'neo/rails/scenarios/test_helper'
+      #
+      #   class ActionController::TestCase
+      #     include Neo::Rails::Scenarios::TestHelper
+      #   end
+      #
+      module TestHelper
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Creates test methods for each defined scenario defined in controller.
+          def test_scenarios(options={})
+            controller_class = options.delete(:controller) || self.controller_class
+            raise "no controller_class defined? Use 'tests MyController'" unless controller_class
+            return unless controller_class.respond_to?(:list_scenarios)
+            scenarios = controller_class.list_scenarios
+
+            if except = options.delete(:except)
+              except = Set.new(Array(except))
+              scenarios.reject! { |scenario| except.include?(scenario.name) }
+            end
+
+            return if scenarios.empty?
+
+            scenarios.each do |scenario|
+              method        = scenario.options[:method] || :get
+              path          = scenario.action
+              scenario_name = scenario.name
+
+              test "test scenario #{controller_class}##{method} #{path.inspect}, :scenario => #{scenario_name.inspect}" do
+
+                send(method, path, :id => 1, :scenario => scenario_name)
+                assert_response :success
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo/rails/version.rb

@@ -0,0 +1,5 @@
+module Neo
+  module Rails
+    VERSION = "0.0.1"
+  end
+end

data/neo-rails.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/neo/rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jonas Thiel", "Peter Suschlik"]
+  gem.email         = ["jt@neopoly.de", "ps@neopoly.de"]
+  gem.description   = %q{Some Rails helpers}
+  gem.summary       = %q{Rails mocks, presenters, exposure and scenarios}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "neo-rails"
+  gem.require_paths = ["lib"]
+  gem.version       = Neo::Rails::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest"
+end

data/test/helper.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+
+class NeoRailsCase < MiniTest::Spec
+  class << self
+    alias :context :describe
+    alias :test :it
+  end
+end

data/test/mock_test.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+require 'neo/rails/mock'
+
+class MockTest < NeoRailsCase
+  context :tagged do
+    let(:mock) { Neo::Rails::Mock.new(:foo, :bar) }
+
+    test "has mock_description" do
+      assert_equal "Foo, Bar", mock.mock.description
+    end
+
+    test "mock_tagged?" do
+      assert mock.mock.tagged?(:foo)
+      assert mock.mock.tagged?(:foo)
+      assert mock.mock.tagged?(:bar)
+      refute mock.mock.tagged?(:baz)
+    end
+  end
+
+  context :untagged do
+    let(:mock) { Neo::Rails::Mock.new }
+
+    test "has empty mock_description" do
+      assert_equal "", mock.mock.description
+    end
+
+    test "is not mock_tagged?" do
+      refute mock.mock.tagged?(:foo)
+      refute mock.mock.tagged?(:bar)
+    end
+  end
+end

data/test/presenter_test.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+require 'neo/rails/presenter'
+
+class PresenterTest < NeoRailsCase
+  User = Struct.new(:name, :team)
+  Team = Struct.new(:name)
+
+  class BasePresenter
+    include Neo::Rails::Presenter
+  end
+
+  class UserPresenter < BasePresenter
+    def initialize(user)
+      @user = user
+    end
+
+    def name
+      @user.name
+    end
+
+    def team
+      @team ||= TeamPresenter.new(@user.team)
+    end
+
+    def link
+      view_context.link_to "/user/#{name}", name
+    end
+  end
+
+  class TeamPresenter < BasePresenter
+    def initialize(team)
+      @team = team
+    end
+
+    def name
+      @team.name
+    end
+
+    def link
+      view_context.link_to "/team/#{name}", name
+    end
+  end
+
+  class ViewContext
+    def link_to(path, name)
+      %{<a href="#{path}">#{name}</a>}
+    end
+  end
+
+  before do
+    Neo::Rails::Presenter.view_context = ViewContext.new
+  end
+
+  let(:team) { Team.new("A-Team") }
+  let(:user) { User.new("Mr T.", team) }
+
+  context "with user_presenter" do
+    let(:user_presenter) { UserPresenter.new(user) }
+
+    test "creates a presenter providing current view_context" do
+      assert_instance_of ViewContext, user_presenter.view_context
+    end
+
+    test "shares view_context with sub presenters" do
+      assert_same user_presenter.view_context, user_presenter.team.view_context
+    end
+
+    test "uses view_context's methods" do
+      assert user_presenter.link
+      assert user_presenter.team.link
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: neo-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonas Thiel
+- Peter Suschlik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Some Rails helpers
+email:
+- jt@neopoly.de
+- ps@neopoly.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/assets/stylesheets/neo-rails.css
+- lib/assets/stylesheets/neo/rails/scenarios/render_scenarios_list.css.sass
+- lib/neo-rails.rb
+- lib/neo/rails.rb
+- lib/neo/rails/engine.rb
+- lib/neo/rails/exposure.rb
+- lib/neo/rails/mock.rb
+- lib/neo/rails/presenter.rb
+- lib/neo/rails/presenter/test_helper.rb
+- lib/neo/rails/scenarios.rb
+- lib/neo/rails/scenarios/rails_helper.rb
+- lib/neo/rails/scenarios/test_helper.rb
+- lib/neo/rails/version.rb
+- neo-rails.gemspec
+- test/helper.rb
+- test/mock_test.rb
+- test/presenter_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rails mocks, presenters, exposure and scenarios
+test_files:
+- test/helper.rb
+- test/mock_test.rb
+- test/presenter_test.rb