controll 0.2.0

data/lib/controll/helper/params.rb

@@ -0,0 +1,20 @@
+module Controll
+  module Helper
+    module Params 
+      extend ActiveSupport::Concern
+      include Controll::Helper::HashAccess
+
+      module ClassMethods
+        def param_methods *args
+          options = args.extract_options!
+          names = args
+          hash_access_method *names, options.merge(hash: :params)
+        end
+
+        def param_method name, options = {}
+          hash_access_method name, options.merge(hash: :params)
+        end
+      end
+    end
+  end
+end

data/lib/controll/helper/path_resolver.rb

@@ -0,0 +1,45 @@
+module Controll
+  module Helper
+    class PathResolver
+      class PathResolverError < StandardError; end
+
+      attr_reader :caller
+
+      def initialize caller
+        @caller = caller
+      end
+
+      def extract_path type, *args
+        if args.first.kind_of?(Symbol)
+          raise "Caller must have a notice method" unless caller.respond_to? :notice
+          caller.notice args.first
+          resolve_path type
+        else      
+          args.empty? ? resolve_path(type) : args.first
+        end
+      end
+
+      def resolve_path type
+        raise "Caller must have a #main_event method" unless caller.respond_to? :main_event
+        caller.send(type).each do |path, events|
+          return path.to_s if matches? events
+        end
+        raise PathResolverError, "Path could not be resolved for: #{event_name}"
+      end
+
+      protected
+
+      def matches? events
+        event_matcher.match?(events)
+      end
+
+      def event_matcher
+        @event_matcher ||= EventMatcher.new event
+      end
+
+      def event
+        @event ||= caller.main_event
+      end
+    end
+  end
+end

data/lib/controll/helper/session.rb

@@ -0,0 +1,20 @@
+module Controll
+  module Helper
+    module Session
+      extend ActiveSupport::Concern
+      include Controll::Helper::HashAccess
+
+      module ClassMethods
+        def session_methods *args
+          options = args.extract_options!
+          names = args
+          hash_access_method *names, options.merge(hash: :session)
+        end
+        
+        def session_method name, options = {}
+          hash_access_method name, options.merge(hash: :session)
+        end
+      end
+    end
+  end
+end

data/lib/controll/notify.rb

@@ -0,0 +1,7 @@
+module Controll
+  module Notify
+    autoload :Base,     'controll/notify/base'
+    autoload :Flash,    'controll/notify/flash'
+    autoload :Typed,    'controll/notify/typed'
+  end
+end

data/lib/controll/notify/base.rb

@@ -0,0 +1,75 @@
+require 'liquid'
+require 'controll/notify/flash'
+
+module Controll
+  module Notify
+    class Base < Flash
+      class NotifyMappingError < StandardError; end
+
+      def notify name, options = {}      
+        @options.merge! options if options.kind_of? Hash
+        signal notify_msg(name)
+      end
+
+      def self.inherited(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        attr_reader :signal_type
+
+        def type name
+          @signal_type = name
+        end
+      end
+
+      protected
+
+      def notify_msg name, opts = {}
+        opts = options.merge(opts).stringify_keys
+
+        msg = send(name) if respond_to? name
+        msg ||= messages[name.to_sym] if respond_to? :messages
+        msg ||= name.to_sym
+
+        # if name is not mapped to a message, it could well be, that the 
+        # event should not generate a nofification message
+        return nil if !msg
+                
+        # try various approaches!
+        case msg
+        when Symbol
+          translate msg, opts
+        when String
+          msg.strip!
+          return replace_args(msg, opts) if msg =~ /{{.*}}/
+          msg
+        else
+          msg_error!
+        end
+      rescue
+      end
+
+      def msg_error!
+        raise NotifyMappingError, "Notify message could not be generated for: #{name}"
+      end
+
+      def translate msg, opts = {}
+        I18n.t i18n_key(msg), opts.symbolize_keys
+      end
+
+      def replace_args msg, opts
+         # Parses and compiles the template
+        Liquid::Template.parse(msg).render(opts)
+      end
+
+      def i18n_key msg
+        parts = self.class.name.split('::')
+        middle = parts[1..-2].join('.').underscore
+        type = parts.last.sub(/Msg$/, '').underscore
+        ns = [middle, type].join('.').sub /^./, ''
+        [ns,msg].join('.')
+      end        
+    end
+  end
+end

data/lib/controll/notify/flash.rb

@@ -0,0 +1,52 @@
+module Controll
+  module Notify
+    class Flash
+      attr_reader :controller
+
+      def initialize controller, options = {}
+        @controller = controller
+        @options = options if options.kind_of? Hash
+      end
+
+      protected
+
+      def options
+        @options ||= {}
+      end
+
+      delegate :flash, to: :controller
+
+      class << self
+        attr_writer :types
+
+        def types
+          @types ||= [:notice, :error, :warning, :success]
+        end
+
+        def add_types *types
+          @types += types.flatten
+        end
+        alias_method :add_type, :add_types
+      end
+
+      def signal msg, type = nil
+        return if msg.blank?
+        type ||= signal_type || :notice
+        raise ArgumentError, "Unsupported flash type: #{type}. Register via #{self.class.name}#types or #add_type" unless valid_type? type
+        flash[type] = msg unless type.blank?
+      end
+
+      def valid_type? type
+        types.include? type.to_sym
+      end
+
+      def types
+        self.class.types
+      end
+
+      def signal_type
+        self.class.signal_type
+      end
+    end
+  end
+end

data/lib/controll/notify/typed.rb

@@ -0,0 +1,39 @@
+require 'controll/notify/flash'
+
+module Controll
+  module Notify
+    class Typed < Flash
+      class MissingNotifyClass < StandardError; end
+
+      def notice        
+        raise MissingNotifyClass, "#{msg_class(:notice)} class missing" unless msg_class(:notice)
+        @notice ||= msg_class(:notice).new flash #, options
+      end
+
+      def error
+        raise MissingNotifyClass, "#{msg_class(:warning)} class missing" unless msg_class(:error)
+        @error ||= msg_class(:error).new flash #, options
+      end
+
+      def success
+        raise MissingNotifyClass, "#{msg_class(:success)} class missing" unless msg_class(:success)
+        @success ||= msg_class(:success).new flash #, options
+      end
+
+      def warning
+        raise MissingNotifyClass, "#{msg_class(:warning)} class missing" unless msg_class(:warning)
+        @warning ||= msg_class(:warning).new flash #, options
+      end
+
+      protected
+
+      def msg_class name
+        msg_classes[name] ||= "#{self.class}::#{name.to_s.camelize}Msg".constantize
+      end 
+
+      def msg_classes
+        @msg_classes ||= {}
+      end
+    end
+  end
+end

data/spec/acceptance/app_test.rb

@@ -0,0 +1,156 @@
+require 'helper'
+require 'capybara'
+require 'capybara_minitest_spec'
+require 'capybara/poltergeist'
+require 'socket'
+
+module FocusedController
+  module Test
+    def self.port
+      @port ||= begin
+        server = TCPServer.new('127.0.0.1', 0)
+        port   = server.addr[1]
+      ensure
+        server.close if server
+      end
+    end
+  end
+end
+
+Capybara.run_server = false
+Capybara.app_host   = "http://127.0.0.1:#{FocusedController::Test.port}"
+
+describe 'acceptance test' do
+  def app_root
+    TEST_ROOT + '/app'
+  end
+
+  def within_test_app
+    Bundler.with_clean_env do
+      Dir.chdir(app_root) do
+        begin
+          prev_gemfile, ENV['BUNDLE_GEMFILE'] = ENV['BUNDLE_GEMFILE'], "#{app_root}/Gemfile"
+          prev_rubyopt, ENV['RUBYOPT']        = ENV['RUBYOPT'], nil
+          ENV['RAILS_VERSION'] = ActionPack::VERSION::STRING
+          yield
+        ensure
+          ENV['BUNDLE_GEMFILE'] = prev_gemfile
+          ENV['RUBYOPT']        = prev_rubyopt
+        end
+      end
+    end
+  end
+
+  def run_without_bundle_exec(command)
+    within_test_app do
+      `#{command}`
+      $?.must_equal 0
+    end
+  end
+
+  def run_command(command)
+    run_without_bundle_exec "bundle exec #{command}"
+  end
+
+  def read_output(stream)
+    read = IO.select([stream], [], [stream], 0.1)
+    output = ""
+    loop { output << stream.read_nonblock(1024) } if read
+    output
+  rescue Errno::EAGAIN, Errno::EWOULDBLOCK, EOFError
+    output
+  end
+
+  # This spawns a server process to run the app under test,
+  # and then waits for it to successfully come up so we can
+  # actually run the test.
+  def start_server
+    within_test_app do
+      IO.popen("bundle exec rails s -p #{FocusedController::Test.port} 2>&1") do |out|
+        start   = Time.now
+        started = false
+        output  = ""
+        timeout = 60.0
+
+        while !started && !out.eof? && Time.now - start <= timeout
+          output << read_output(out)
+          sleep 0.1
+
+          begin
+            TCPSocket.new('127.0.0.1', FocusedController::Test.port)
+          rescue Errno::ECONNREFUSED
+          else
+            started = true
+          end
+        end
+
+        raise "Server failed to start:\n#{output}" unless started
+
+        yield
+
+        Process.kill('KILL', out.pid)
+      end
+    end
+  end
+
+  before do
+    run_without_bundle_exec "bundle check >/dev/null || bundle update >/dev/null"
+  end
+
+  let(:s) { Capybara::Session.new(:poltergeist, nil) }
+
+  it 'does basic CRUD actions successfully' do
+    start_server do
+      s.visit '/posts'
+
+      s.click_link 'New Post'
+      s.fill_in 'Title', :with => 'Hello world'
+      s.fill_in 'Body',  :with => 'Omg, first post'
+      s.click_button 'Create Post'
+
+      s.click_link 'Back'
+      s.must_have_content 'Hello world'
+      s.must_have_content 'Omg, first post'
+
+      s.click_link 'Show'
+      s.must_have_content 'Hello world'
+      s.must_have_content 'Omg, first post'
+
+      s.click_link 'Edit'
+      s.fill_in 'Title', :with => 'Goodbye world'
+      s.fill_in 'Body',  :with => 'Omg, edited'
+      s.click_button 'Update Post'
+      s.must_have_content 'Goodbye world'
+      s.must_have_content 'Omg, edited'
+
+      s.click_link 'Back'
+      s.click_link 'Destroy'
+      s.wont_have_content 'Goodbye world'
+      s.wont_have_content 'Omg, edited'
+    end
+  end
+
+  it 'runs a functional test' do
+    run_command "ruby -Itest test/functional/posts_controller_test.rb"
+  end
+
+  it 'runs a unit test' do
+    run_command "ruby -Itest test/unit/controllers/posts_controller_test.rb"
+  end
+
+  it 'runs an isolated unit test' do
+    run_command "ruby -Itest test/unit/controllers/posts_controller_isolated_test.rb"
+  end
+
+  it 'runs a functional spec' do
+    run_command "rspec spec/controllers/posts_controller_spec.rb"
+  end
+
+  it 'runs a unit spec' do
+    run_command "rspec spec/unit/controllers/posts_controller_spec.rb"
+  end
+
+  it 'runs an isolated unit spec' do
+    run_command "rspec spec/unit/controllers/posts_controller_isolated_spec.rb"
+  end
+end

data/spec/app/.gitignore

@@ -0,0 +1,15 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/spec/app/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gem 'rails', ENV['RAILS_VERSION'] || '~> 3.2.1'
+gem 'focused_controller', :path => '../..'
+gem 'rspec'
+gem 'rspec-rails'