kuji-mercury-rails 0.3.2

data/features/support/selectors.rb

@@ -0,0 +1,44 @@
+module HtmlSelectorsHelpers
+  # Maps a name to a selector. Used primarily by the
+  #
+  #   When /^(.+) within (.+)$/ do |step, scope|
+  #
+  # step definitions in web_steps.rb
+  #
+  def selector_for(locator)
+
+    # add in for mercury support
+    result = mercury_selector_for(locator)
+    return result if result.present?
+
+    case locator
+
+      when /the page/
+        "html > body"
+
+      # Add more mappings here.
+      # Here is an example that pulls values out of the Regexp:
+      #
+      #  when /the (notice|error|info) flash/
+      #    ".flash.#{$1}"
+
+      # You can also return an array to use a different selector
+      # type, like:
+      #
+      #  when /the header/
+      #    [:xpath, "//header"]
+
+      # This allows you to provide a quoted selector as the scope
+      # for "within" steps as was previously the default for the
+      # web steps:
+      when /"(.+)"/
+        $1
+
+      else
+        raise "Can't find mapping from \"#{locator}\" to a selector.\n" +
+                      "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(HtmlSelectorsHelpers)

data/lib/generators/mercury/install/install_generator.rb

@@ -0,0 +1,49 @@
+module Mercury
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root Mercury::Engine.root
+
+      desc "Installs Mercury into your application by copying the configuration file."
+
+      class_option :orm, :default => 'active_record', :banner => 'mongoid',
+                   :desc => 'ORM for required models -- active_record, or mongoid'
+
+      class_option :full, :type => :boolean, :aliases => '-g',
+                   :desc => 'Full installation will install the layout and css overrides for easier customization.'
+
+      def copy_config
+        copy_file 'vendor/assets/javascripts/mercury.js', 'app/assets/javascripts/mercury.js'
+      end
+
+      def add_routes
+        route %Q{Mercury::Engine.routes}
+      end
+
+      def copy_models
+        if options[:orm] == 'mongoid'
+          copy_file 'lib/generators/mercury/install/templates/mongoid_paperclip_image.rb', 'app/models/mercury/image.rb'
+        else
+          copy_file 'app/models/mercury/image.rb' if options[:full]
+        end
+      end
+
+      def copy_layout_and_css_overrides
+        if options[:full] || yes?("Install the layout and CSS overrides files? [yN]")
+          copy_file 'app/views/layouts/mercury.html.erb', 'app/views/layouts/mercury.html.erb'
+          copy_file 'vendor/assets/stylesheets/mercury_overrides.css', 'app/assets/stylesheets/mercury_overrides.css'
+        end
+      end
+
+      def copy_authentication_overrides
+        if options[:full] || yes?("Install the authentication file so you can restrict access to editing? [yN]")
+          copy_file 'lib/mercury/authentication.rb'
+        end
+      end
+
+      def display_readme
+        readme 'POST_INSTALL' if behavior == :invoke
+      end
+
+    end
+  end
+end

data/lib/generators/mercury/install/templates/mongoid_paperclip_image.rb

@@ -0,0 +1,17 @@
+class Mercury::Image
+  include Mongoid::Document
+  include Mongoid::Paperclip
+
+  has_mongoid_attached_file :image
+
+  validates_presence_of :image
+
+  delegate :url, :to => :image
+
+  def serializable_hash(options = nil)
+    options ||= {}
+    options[:methods] ||= []
+    options[:methods] << :url
+    super(options)
+  end
+end

data/lib/mercury-rails.rb

@@ -0,0 +1,3 @@
+require 'paperclip'
+
+require File.expand_path('../config/engine', File.dirname(__FILE__))

data/lib/mercury/authentication.rb

@@ -0,0 +1,8 @@
+module Mercury
+  module Authentication
+
+    def can_edit?
+      true # check here to see if the user is logged in/has access
+    end
+  end
+end

data/spec/javascripts/mercury/dialog_spec.js.coffee

@@ -0,0 +1,281 @@
+describe "Mercury.Dialog", ->
+
+  template 'mercury/dialog.html'
+
+  beforeEach ->
+    $.fx.off = true
+    Mercury.determinedLocale =
+      top: {'hello world!': 'bork! bork!'}
+      sub: {'foo': 'Bork!'}
+
+  afterEach ->
+    delete(@dialog)
+    Mercury.config.localization.enabled = false
+
+
+  describe "constructor", ->
+
+    beforeEach ->
+      @buildSpy = spyOn(Mercury.Dialog.prototype, 'build').andCallFake(=>)
+      @bindEventsSpy = spyOn(Mercury.Dialog.prototype, 'bindEvents').andCallFake(=>)
+      @preloadSpy = spyOn(Mercury.Dialog.prototype, 'preload').andCallFake(=>)
+
+    it "expects a url and name", ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo')
+      expect(@dialog.url).toEqual('/blank.html')
+      expect(@dialog.name).toEqual('foo')
+
+    it "accepts options", ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {for: 'something', foo: 'bar'})
+      expect(@dialog.options).toEqual({for: 'something', foo: 'bar'})
+
+    it "calls build", ->
+      @dialog = new Mercury.Dialog()
+      expect(@buildSpy.callCount).toEqual(1)
+
+    it "calls bindEvents", ->
+      @dialog = new Mercury.Dialog()
+      expect(@bindEventsSpy.callCount).toEqual(1)
+
+    it "preloads if configured", ->
+      @dialog = new Mercury.Dialog()
+      expect(@preloadSpy.callCount).toEqual(1)
+
+
+  describe "#build", ->
+
+    beforeEach ->
+      @bindEventsSpy = spyOn(Mercury.Dialog.prototype, 'bindEvents').andCallFake(=>)
+      @preloadSpy = spyOn(Mercury.Dialog.prototype, 'preload').andCallFake(=>)
+
+    it "builds an element", ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+      html = $('<div>').html(@dialog.element).html()
+      expect(html).toContain('class="mercury-dialog mercury-foo-dialog loading"')
+      expect(html).toContain('style="display:none"')
+
+    it "appends to any element", ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#dialog_container'})
+      expect($('#dialog_container .mercury-dialog').length).toEqual(1)
+
+
+  describe "#bindEvents", ->
+
+    it "only observes mousedown to stop the event"
+
+
+  describe "#preload", ->
+
+    beforeEach ->
+      @loadSpy = spyOn(Mercury.Dialog.prototype, 'load').andCallFake(=>)
+
+    it "calls load if configured", ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test', preload: true})
+      expect(@loadSpy.callCount).toEqual(1)
+
+    it "doesn't call load if configured", ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test', preload: false})
+      expect(@loadSpy.callCount).toEqual(0)
+
+
+  describe "#toggle", ->
+
+    beforeEach ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+
+    it "shows or hides", ->
+      expect(@dialog.element.css('display')).toEqual('none')
+      @dialog.toggle()
+      expect(@dialog.element.css('display')).toEqual('block')
+      @dialog.toggle()
+      expect(@dialog.element.css('display')).toEqual('none')
+
+
+  describe "#resize", ->
+
+    beforeEach ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+
+    it "calls show", ->
+      spy = spyOn(Mercury.Dialog.prototype, 'show').andCallFake(=>)
+      @dialog.resize()
+      expect(spy.callCount).toEqual(1)
+
+
+  describe "#show", ->
+
+    beforeEach ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+
+    it "triggers a custom event to hide all other dialogs", ->
+      spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+      @dialog.show()
+      expect(spy.callCount).toEqual(1)
+      expect(spy.argsForCall[0]).toEqual(['hide:dialogs', @dialog])
+
+    describe "when already loaded", ->
+
+      beforeEach ->
+        @dialog.loaded = true
+
+      it "sets width and height on the element to auto", ->
+        @dialog.element.css({width: 100})
+        @dialog.show()
+        expect(@dialog.element.get(0).style.width).toEqual('auto')
+        expect(@dialog.element.get(0).style.height).toEqual('auto')
+
+      it "calls position", ->
+        spy = spyOn(Mercury.Dialog.prototype, 'position').andCallFake(=>)
+        @dialog.show()
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual([true])
+
+      it "calls appear", ->
+        spy = spyOn(Mercury.Dialog.prototype, 'appear').andCallFake(=>)
+        @dialog.show()
+        expect(spy.callCount).toEqual(1)
+
+    describe "when not loaded", ->
+
+      it "calls position", ->
+        spy = spyOn(Mercury.Dialog.prototype, 'position').andCallFake(=>)
+        @dialog.show()
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual([])
+
+      it "calls appear", ->
+        spy = spyOn(Mercury.Dialog.prototype, 'appear').andCallFake(=>)
+        @dialog.show()
+        expect(spy.callCount).toEqual(1)
+
+
+  describe "#position", ->
+
+    it "does nothing and is there as an interface method"
+
+
+  describe "#appear", ->
+
+    beforeEach ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+
+    it "animates the dialog in", ->
+      @dialog.appear()
+      expect(@dialog.element.css('display')).toEqual('block')
+      expect(parseFloat(@dialog.element.css('opacity')).toPrecision(2)).toEqual('0.95')
+
+    it "calls load if it's not already loaded", ->
+
+
+  describe "#hide", ->
+
+    beforeEach ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+
+    it "hides the dialog", ->
+      @dialog.element.css({display: 'block'})
+      @dialog.hide()
+      expect(@dialog.element.css('display')).toEqual('none')
+      expect(@dialog.visible).toEqual(false)
+
+
+  describe "#load", ->
+
+    beforeEach ->
+      @spyFunction = ->
+      Mercury.dialogHandlers.foo = ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test', for: $('#button')})
+
+    it "does nothing if there's no url", ->
+      spy = spyOn($, 'ajax').andCallFake(=>)
+      @dialog.url = false
+      @dialog.load()
+      expect(spy.callCount).toEqual(0)
+
+    describe "on a preloaded view", ->
+
+      beforeEach ->
+        Mercury.preloadedViews = {'/blank.html': 'this is the preloaded content'}
+
+      afterEach ->
+        Mercury.preloadedViews = {}
+
+      it "calls loadContent with the content in the preloaded view", ->
+        spy = spyOn(Mercury.Dialog.prototype, 'loadContent').andCallFake(=>)
+        @dialog.load()
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual(['this is the preloaded content'])
+
+    describe "when not a preloaded view", ->
+
+      it "makes an ajax request", ->
+        spy = spyOn($, 'ajax').andCallFake(=>)
+        @dialog.load()
+        expect(spy.callCount).toEqual(1)
+
+      describe "on success", ->
+
+        beforeEach ->
+          @loadContentSpy = spyOn(Mercury.Dialog.prototype, 'loadContent').andCallFake(=>)
+          @ajaxSpy = spyOn($, 'ajax').andCallFake (url, options) =>
+            options.success('return value') if (options.success)
+
+        it "calls loadContent with data", ->
+          @dialog.load()
+          expect(@loadContentSpy.callCount).toEqual(1)
+          expect(@loadContentSpy.argsForCall[0]).toEqual(['return value'])
+
+        it "calls a dialog handler if there's one", ->
+          spy = spyOn(Mercury.dialogHandlers, 'foo').andCallFake(=>)
+          @dialog.load()
+          expect(spy.callCount).toEqual(1)
+
+        it "calls a callback if one was provided", ->
+          spy = spyOn(@, 'spyFunction').andCallFake(=>)
+          @dialog.load(@spyFunction)
+          expect(spy.callCount).toEqual(1)
+
+      describe "on failure", ->
+
+        beforeEach ->
+          @alertSpy = spyOn(window, 'alert').andCallFake(=>)
+          @ajaxSpy = spyOn($, 'ajax').andCallFake (url, options) =>
+            options.error() if (options.error)
+
+        it "hides", ->
+          spy = spyOn(Mercury.Dialog.prototype, 'hide').andCallFake(=>)
+          @dialog.load()
+          expect(spy.callCount).toEqual(1)
+
+        it "removes the pressed state for it's button", ->
+          $('#button').addClass('pressed')
+          @dialog.load()
+          expect($('#button').hasClass('pressed')).toEqual(false)
+
+        it "alerts the user", ->
+          @dialog.load()
+          expect(@alertSpy.callCount).toEqual(1)
+          expect(@alertSpy.argsForCall[0]).toEqual(['Mercury was unable to load /blank.html for the "foo" dialog.'])
+
+
+  describe "#loadContent", ->
+
+    beforeEach ->
+      @dialog = new Mercury.Dialog('/blank.html', 'foo', {appendTo: '#test'})
+
+    it "sets loaded to be true", ->
+      @dialog.loadContent()
+      expect(@dialog.loaded).toEqual(true)
+
+    it "removes the loading class from the element", ->
+      @dialog.loadContent()
+      expect(@dialog.element.hasClass('loading')).toEqual(false)
+
+    it "sets the element html to be the data passed to it", ->
+      @dialog.loadContent('<span>hello world!</span>')
+      expect(@dialog.element.html()).toEqual('<span>hello world!</span>')
+
+    it "translates the content if configured", ->
+      Mercury.config.localization.enabled = true
+      @dialog.loadContent('<span>hello world!</span>')
+      expect(@dialog.element.html()).toEqual('<span>bork! bork!</span>')

data/spec/javascripts/mercury/dialogs/backcolor_spec.js.coffee

@@ -0,0 +1,37 @@
+describe "Mercury.dialogHandlers.backColor", ->
+
+  template 'mercury/dialogs/backcolor.html'
+
+  beforeEach ->
+    @dialog = {element: $('#test'), button: $('#button')}
+    Mercury.dialogHandlers.backColor.call(@dialog)
+
+  describe "when a .picker or .last-picked element is clicked", ->
+
+    it "sets the last picked color to whatever was selected", ->
+      $('.last-picked').css({background: '#0000FF'})
+      jasmine.simulate.click($('#white').get(0))
+      expect($('.last-picked').css('backgroundColor')).toEqual('rgb(255, 255, 255)')
+      jasmine.simulate.click($('#red').get(0))
+      expect($('.last-picked').css('backgroundColor')).toEqual('rgb(255, 0, 0)')
+
+    it "sets the background color of the button", ->
+      $('#button').css({background: '#0000FF'})
+      jasmine.simulate.click($('#white').get(0))
+      expect($('#button').css('backgroundColor')).toEqual('rgb(255, 255, 255)')
+      jasmine.simulate.click($('#red').get(0))
+      expect($('#button').css('backgroundColor')).toEqual('rgb(255, 0, 0)')
+
+    it "triggers an action", ->
+      spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+      jasmine.simulate.click($('#white').get(0))
+      expect(spy.callCount).toEqual(1)
+      expect(spy.argsForCall[0]).toEqual(['action', {action: 'backColor', value: 'rgb(255, 255, 255)'}])
+
+
+  describe "when any other element is clicked", ->
+
+    it "does nothing", ->
+      spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+      jasmine.simulate.click($('#green').get(0))
+      expect(spy.callCount).toEqual(0)