drink-menu 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aa0caded737aae5b8e19f02d234a62bec5532129
+  data.tar.gz: 3670d72c16d59197c56304cfe94992ab2218e71f
+SHA512:
+  metadata.gz: 30a6f653df7169b157e7424c5be84b35c34c3f339a88a3361f057f3e3822092005c2df993a1e91fe6dca366b2b70bf2a83a975f83fc719f849750ed8b301b892
+  data.tar.gz: f1d041f9171d4c9cd4ffe7671d60a82383c9d3b7d9fcf9868dd3fdf90eab3d7cc183adc37993931be0793b57bc91cdc2f496ec49c4483f455a33ae977d8710e3

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joe Fiorini
+
+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,80 @@
+# Drink::Menu
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'drink-menu'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install drink-menu
+
+## Usage
+
+Drink Menu separates menu layout from menu definition. Menu definition looks like:
+
+
+```ruby
+class MainMenu
+  extend DrinkMenu::MenuBuilder
+
+  menuItem :progress do |item|
+  end
+
+  menu :sites_list, itemsFromCollection: Staticly.sitesList, titleProperty: :name
+
+  menuItem :open_site, title: 'Open Site', submenu: :sites_list
+
+  menuItem :create_site, title: 'Create Site'
+  menuItem :export, title: 'Export to Folder...'
+  menuItem :import, title: 'Import Folder as Site...'
+  menuItem :force_rebuild, title: 'Force Rebuild'
+  menuItem :about, title: 'About Staticly'
+  menuItem :quit, title: 'Quit'
+
+
+  iconImage = NSImage.imageNamed "status-icon-off"
+  iconImage.template = true
+
+end
+```
+
+and then layout is as simple as:
+
+```ruby
+
+class MainMenu
+  extend DrinkMenu::MenuBuilder
+
+  statusBarMenu :main_menu, icon: iconImage, statusItemViewClass: StatusItemView do
+    open_site
+    create_site
+    ___
+    export
+    import
+    force_rebuild
+    ___
+    about
+    quit
+  end
+
+end
+```
+
+More detailed documentation coming soon.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,23 @@
+require "bundler/gem_tasks"
+$:.unshift("/Library/RubyMotion/lib")
+
+if ENV['platform'] == 'osx'
+    require 'motion/project/template/osx'
+else
+  raise "The drink-menu gem must be used within an OSX project."
+end
+
+Bundler.setup
+Bundler.require
+
+require 'motion-cocoapods'
+
+Motion::Project::App.setup do |app|
+  app.name = 'drink-menu'
+  app.identifier = 'com.densitypop.drink-menu'
+  app.specs_dir = "spec/"
+
+  app.pods do
+    pod 'ReactiveCocoa'
+  end
+end

data/drink-menu.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'drink-menu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "drink-menu"
+  spec.version       = DrinkMenu::VERSION
+  spec.authors       = ["Joe Fiorini"]
+  spec.email         = ["joe@joefiorini.com"]
+  spec.description   = %q{An easy way to define menu items and visually lay out menus for your OSX apps. Uses ReactiveCocoa to provide a nice syntax for responding to menu interactions. Also provides live-binding to collections, which makes keeping menus up-to-date a breeze!}
+  spec.summary       = %q{OSX menus - the ruby way}
+  spec.homepage      = "https://github.com/joefiorini/drink-menu"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0.0"
+
+  spec.add_dependency "motion-cocoapods"
+  spec.add_dependency "cocoapods", "= 0.20.2"
+end

data/lib/drink-menu.rb

@@ -0,0 +1,9 @@
+unless defined?(Motion::Project::Config)
+    raise "The drink-menu gem must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'drink-menu/**/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/lib/drink-menu/ext/forwardable.rb

@@ -0,0 +1,131 @@
+module Forwardable
+  FORWARDABLE_VERSION = "1.1.0"
+
+  @debug = nil
+  class << self
+    attr_accessor :debug
+  end
+
+  # Takes a hash as its argument.  The key is a symbol or an array of
+  # symbols.  These symbols correspond to method names.  The value is
+  # the accessor to which the methods will be delegated.
+  #
+  # :call-seq:
+  #    delegate method => accessor
+  #    delegate [method, method, ...] => accessor
+  #
+  def instance_delegate(hash)
+    hash.each{ |methods, accessor|
+      methods = [methods] unless methods.respond_to?(:each)
+      methods.each{ |method|
+        def_instance_delegator(accessor, method)
+      }
+    }
+  end
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  def def_instance_delegators(accessor, *methods)
+    methods.delete("__send__")
+    methods.delete("__id__")
+    for method in methods
+      def_instance_delegator(accessor, method)
+    end
+  end
+
+  def def_instance_delegator(accessor, method, ali = method)
+    accessor = accessor.id2name if accessor.kind_of?(Integer)
+    method = method.id2name if method.kind_of?(Integer)
+    ali = ali.id2name if ali.kind_of?(Integer)
+    activity = Proc.new do
+      define_method("#{ali}") do |*args, &block|
+        begin
+          instance_variable_get(accessor).__send__(method, *args, &block)
+        rescue Exception
+          $@.delete_if{|s| %r"#{Regexp.quote(__FILE__)}"o =~ s} unless Forwardable::debug
+          Kernel::raise
+        end
+      end
+    end
+
+    # If it's not a class or module, it's an instance
+    begin
+      module_eval(&activity)
+    rescue
+      instance_eval(&activity)
+    end
+  end
+
+  alias delegate instance_delegate
+  alias def_delegators def_instance_delegators
+  alias def_delegator def_instance_delegator
+end
+
+module SingleForwardable
+  # Takes a hash as its argument.  The key is a symbol or an array of
+  # symbols.  These symbols correspond to method names.  The value is
+  # the accessor to which the methods will be delegated.
+  #
+  # :call-seq:
+  #    delegate method => accessor
+  #    delegate [method, method, ...] => accessor
+  #
+  def single_delegate(hash)
+    hash.each{ |methods, accessor|
+      methods = [methods] unless methods.respond_to?(:each)
+      methods.each{ |method|
+        def_single_delegator(accessor, method)
+      }
+    }
+  end
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  def def_single_delegators(accessor, *methods)
+    methods.delete("__send__")
+    methods.delete("__id__")
+    for method in methods
+      def_single_delegator(accessor, method)
+    end
+  end
+
+  #
+  # Defines a method _method_ which delegates to _obj_ (i.e. it calls
+  # the method of the same name in _obj_).  If _new_name_ is
+  # provided, it is used as the name for the delegate method.
+  #
+  def def_single_delegator(accessor, method, ali = method)
+    instance_eval do
+      define_method("#{ali}") do |*args, &block|
+        begin
+          instance_variable_get(accessor).__send__(method, *args, &block)
+        rescue Exception
+          $@.delete_if{|s| %r"#{Regexp.quote(__FILE__)}"o =~ s} unless Forwardable::debug
+          ::Kernel::raise
+        end
+      end
+    end
+  end
+
+  alias delegate single_delegate
+  alias def_delegators def_single_delegators
+  alias def_delegator def_single_delegator
+end

data/lib/drink-menu/ext/ns_menu_item.rb

@@ -0,0 +1,55 @@
+class NSMenuItem
+  attr_accessor :rac_command
+  attr_accessor :rac_originalTarget
+  attr_accessor :rac_stateSignal
+
+  def rac_command=(command)
+
+    @rac_command = command
+
+    self.enabled = (command && command.canExecute) || true
+
+    return unless command
+
+    # TODO: Set state via binding rather than validateMenuItem
+    # Look at https://github.com/ReactiveCocoa/ReactiveCocoa/blob/2.0-development/ReactiveCocoaFramework/ReactiveCocoa/NSObject%2BRACAppKitBindings.m#L23
+    #
+    self.bind(NSEnabledBinding, toObject: self.rac_command, withKeyPath: "canExecute", options: nil)
+
+    self.rac_hijackActionAndTargetIfNeeded
+
+    @rac_command
+  end
+
+  def rac_stateSignal=(signal)
+    @rac_stateSignal = signal
+    @rac_stateSignal.subscribeNext ->(value){
+      self.state = value
+    }
+  end
+
+  def rac_hijackActionAndTargetIfNeeded
+    hijackSelector = :"rac_commandPerformAction:"
+
+    return if target == self and action == hijackSelector
+
+    NSLog("WARNING: NSControl.rac_command hijacks the control's existing target and action. You can access the original target via the rac_originalTarget property.") if target
+
+    self.rac_originalTarget = target
+
+    self.target = self
+    self.action = hijackSelector
+  end
+
+  def rac_commandPerformAction(sender)
+    rac_command.execute(sender)
+  end
+
+  def validateMenuItem(item)
+    return rac_originalTarget.validateMenuItem(item) if rac_originalTarget and rac_originalTarget.respondsToSelector(:"validateMenuItem:")
+
+    rac_command.canExecute
+  end
+
+end
+

data/lib/drink-menu/menu.rb

@@ -0,0 +1,174 @@
+module DrinkMenu
+  class Menu
+    extend Forwardable
+
+    def_delegators :@menu,
+      :menuBarHeight, :numberOfItems,
+      :itemArray, :isTornOff,
+      :supermenu, :setSupermenu, :supermenu=,
+      :autoenablesItems, :setAutoenablesItems, :autoenablesItems=,
+      :font, :setFont, :font=,
+      :title, :setTitle, :title=,
+      :minimumWidth, :setMinimumWidth, :minimumWidth=,
+      :size, :propertiesToUpdate,
+      :menuChangedMessagesEnabled, :setMenuChangedMessagesEnabled, :menuChangedMessagesEnabled=,
+      :allowsContextMenuPlugins, :setAllowsContextMenuPlugins, :allowsContextMenuPlugins=,
+      :highlightedItem, :delegate, :setDelegate, :delegate=
+
+    attr_reader :menuItems, :menu, :builder, :label
+    attr_accessor :statusItem, :statusItemIcon, :memberCommand, :statusItemTitle, :memberTitleProperty, :itemAddedSubject
+
+    def self.statusMenuWithLabel(label, icon: image, statusItemViewClass: statusItemViewClass, &block)
+      new(label, &block).tap do |menu|
+        menu.createStatusItemWithIcon image, viewClass: statusItemViewClass
+      end
+    end
+
+    def self.statusMenuWithLabel(label, icon: image, &block)
+      new(label, &block).tap do |menu|
+        menu.createStatusItemWithIcon image
+      end
+    end
+
+    def self.statusMenuWithLabel(label, title: title, &block)
+      new(label, &block).tap do |menu|
+        menu.createStatusItemWithTitle title
+      end
+    end
+
+    def self.menuWithLabel(label, title: title, &block)
+      new(label, &block).tap do |menu|
+        menu.title = title
+      end
+    end
+
+    def self.menuWithLabel(label, itemsFromCollection: collection, titleProperty: titleProperty)
+      new(label).tap do |menu|
+        menu.memberTitleProperty = titleProperty
+
+        menu.itemAddedSubject = RACSubject.subject
+
+        @allItemsSignal =
+          menu.itemAddedSubject.flattenMap(->(value){
+            value.command.map(->(v){
+              [label, menu[v.tag]]
+            })
+          })
+
+        menu.memberCommand = @allItemsSignal.multicast(RACReplaySubject.subject)
+        menu.memberCommand.connect
+
+        collection.arrangedObjects.each do |member|
+          menu.addMenuItemForMember member
+        end
+
+        collection.addObserver menu, forKeyPath: "arrangedObjects", options: (NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld), context: nil
+
+      end
+    end
+
+    def initialize(label, &block)
+      @menuItems = {}
+      @label = label
+      @builder = block
+      @menu = NSMenu.alloc.init
+    end
+
+    def <<(item)
+      previousItemTag = @menuItems.keys.last || 0
+      item.tag = previousItemTag + 1
+      @menuItems[item.tag] = item
+      @menu.addItem item.menuItem
+    end
+
+    def addMenuItemForMember(member)
+      item = MenuItem.itemWithLabel(member.hash.to_s, title: member.send(memberTitleProperty))
+      item.representedObject = member
+      item.rac_stateSignal = memberCommand.signal.map ->((_,value)){
+        value.representedObject == item.representedObject
+      }
+
+      self << item
+      itemAddedSubject.sendNext(item)
+
+    end
+
+    def observeValueForKeyPath(keyPath, ofObject: object, change: change, context: context)
+      return unless keyPath == "arrangedObjects"
+      if itemArray.length < object.arrangedObjects.length
+        member = object.arrangedObjects.lastObject
+        addMenuItemForMember(member)
+      end
+    end
+
+    def subscribeToMembers(&block)
+      memberCommand.signal.subscribeNext(block)
+    end
+
+    def subscribe(itemLabel, &block)
+      self[itemLabel].subscribe(&block)
+    end
+
+    def createStatusItemWithTitle(title)
+      @needsStatusItem = true
+      @statusItemTitle = title
+    end
+
+    def createStatusItemWithIcon(image)
+      @needsStatusItem = true
+      @statusItemIcon = image
+    end
+
+    def createStatusItemWithIcon(image, viewClass: viewClass)
+      @needsStatusItem = true
+      @statusItemViewClass = viewClass
+      @statusItemIcon = image
+    end
+
+    def selectItem(label)
+      item = self[label]
+      item.command.execute(item)
+    end
+
+    def selectItemByMember(member)
+      item = @menuItems.values.find do |i|
+        i.representedObject == member
+      end
+      item.command.execute(item)
+    end
+
+    def [](labelOrTag)
+      if labelOrTag.is_a? Fixnum
+        @menuItems[labelOrTag]
+      else
+        @menuItems.values.find do |item|
+          item.label == labelOrTag
+        end
+      end
+    end
+
+    def needsStatusItem?
+      @needsStatusItem
+    end
+
+    def createStatusItem!
+      statusBar = NSStatusBar.systemStatusBar
+      @statusItem = statusBar.statusItemWithLength(NSSquareStatusItemLength)
+      @statusItem.highlightMode = true
+
+      @statusItem.menu = menu
+
+      if @statusItemViewClass
+        statusItemView = @statusItemViewClass.viewWithStatusItem(@statusItem)
+        @statusItem.menu.delegate = @statusItemView
+        @statusItem.view = statusItemView
+      end
+
+      @statusItem.title = @statusItemTitle
+      @statusItem.image = @statusItemIcon
+
+      @statusItem
+    end
+
+  end
+end

data/lib/drink-menu/menu_builder.rb

@@ -0,0 +1,83 @@
+module DrinkMenu
+  module MenuBuilder
+
+    class Context
+        def initialize(menu, menuItems={})
+          @menu = menu
+          @menuItems = menuItems
+        end
+
+        def ___
+          @menu << MenuItem.separatorItem
+        end
+
+        def method_missing(meth, *args)
+          if @menuItems.key?(meth)
+            @menu << @menuItems[meth]
+          else
+            super
+          end
+        end
+    end
+
+    def <<(item)
+      @menuItems ||= {}
+      @menuItems[item.label] = item
+    end
+
+    def menuItem(label, title: title)
+      @menuItems ||= {}
+      @menuItems[label] = MenuItem.itemWithLabel label, title: title
+    end
+
+    def menuItem(label, title: title, submenu: submenu)
+      @menuItems ||= {}
+      @menuItems[label] = MenuItem.itemWithLabel label, title: title, submenu: @menus[submenu]
+    end
+
+    def menuItem(label, &block)
+      @menuItems ||= {}
+      @menuItems[label] = MenuItem.itemWithLabel label, &block
+    end
+
+    def statusBarMenu(label, title: title, &block)
+      @menus ||= {}
+      @menus[label] = Menu.statusMenuWithLabel label, title: title, &block
+    end
+
+    def statusBarMenu(label, icon: image, statusItemViewClass: statusItemViewClass, &block)
+      @menus ||= {}
+      @menus[label] = Menu.statusMenuWithLabel label, icon: image, statusItemViewClass: statusItemViewClass, &block
+    end
+
+    def statusBarMenu(label, icon: image, &block)
+      @menus ||= {}
+      @menus[label] = Menu.statusMenuWithLabel label, icon: image, &block
+    end
+
+    def menu(label, title: title, &block)
+      @menus ||= {}
+      @menus[label] = Menu.menuWithLabel label, title: title, &block
+    end
+
+    def menu(label, itemsFromCollection: collection, titleProperty: property)
+      @menus ||= {}
+      @menus[label] = Menu.menuWithLabel label, itemsFromCollection: collection, titleProperty: property
+    end
+
+    def [](label)
+      @menus[label]
+    end
+
+    def build!
+      @menus.values.each do |menu|
+        context = Context.new(menu, @menuItems.dup)
+        context.instance_eval(&menu.builder) if menu.builder
+        if menu.needsStatusItem?
+          menu.createStatusItem!
+        end
+      end
+    end
+
+  end
+end

data/lib/drink-menu/menu_item.rb

@@ -0,0 +1,92 @@
+module DrinkMenu
+  class MenuItem
+    extend Forwardable
+
+    attr_accessor :label, :menuItem, :command, :canExecuteSignal
+
+    def_delegators :@menuItem, :isEnabled, :setEnabled, :enabled=,
+                    :tag, :setTag, :tag=,
+                    :image, :setImage, :image=,
+                    :state, :setState, :state=,
+                    :title, :setTitle, :title=,
+                    :isHidden, :setHidden, :hidden=,
+                    :isHiddenOrHasHiddenAncestor,
+                    :target, :setTarget, :target=,
+                    :action, :setAction, :action=,
+                    :onStateImage, :setOnStateImage, :onStateImage=,
+                    :offStateImage, :setOffStateImage, :offStateImage=,
+                    :mixedStateImage, :setMixedStateImage, :mixedStateImage=,
+                    :submenu, :setSubmenu, :submenu=,
+                    :hasSubmenu,
+                    :parentItem,
+                    :isSeparatorItem,
+                    :menu, :setMenu, :menu=,
+                    :keyEquivalent, :setKeyEquivalent, :keyEquivalent=,
+                    :keyEquivalentModifierMask, :setKeyEquivalentModifierMask, :keyEquivalentModifierMask=,
+                    :isAlternate, :setAlternate, :alternate=,
+                    :indentationLevel, :setIndentationLevel, :indentationLevel=,
+                    :toolTip, :setToolTip, :toolTip=,
+                    :representedObject, :setRepresentedObject, :representedObject=,
+                    :view, :setView, :view=,
+                    :rac_command, :rac_command=,
+                    :rac_stateSignal, :rac_stateSignal=,
+                    :isHighlighted
+
+    def self.itemWithLabel(label, title: title)
+      new.tap do |item|
+        item.label = label
+        item.title = title
+      end
+    end
+
+    def self.itemWithLabel(label, title: title, submenu: submenu)
+      new.tap do |item|
+        item.label = label
+        item.title = title
+        item.submenu = submenu.menu
+      end
+    end
+
+    def self.itemWithLabel(label, &block)
+      new.tap do |item|
+        item.label = label
+        block.call item
+      end
+    end
+
+    def self.separatorItem
+      @@separatorId ||= 0
+      @@separatorId += 1
+      label = :"separator#{@@separatorId}"
+      new(NSMenuItem.separatorItem).tap do |item|
+        item.label = label
+      end
+    end
+
+    def initialize(menuItem=nil)
+      @menuItem = menuItem || NSMenuItem.alloc.init
+    end
+
+    def command=(command)
+      self.rac_command = command
+    end
+
+    def command
+      self.rac_command ||= if canExecuteSignal
+                             RACCommand.commandWithCanExecuteSignal canExecuteSignal
+                           else
+                             RACCommand.command
+                           end
+
+      self.rac_command
+    end
+
+    def subscribe(&block)
+      command.map(->(value){
+        [label, self]
+      }).subscribeNext(block)
+    end
+
+  end
+
+end

data/lib/drink-menu/version.rb

@@ -0,0 +1,3 @@
+module DrinkMenu
+  VERSION = "0.1.0"
+end

data/spec/menu_builder_spec.rb

@@ -0,0 +1,87 @@
+class TestMenu; extend DrinkMenu::MenuBuilder; end
+
+describe "sugar for creating menus" do
+
+  it "supports defining menu items" do
+    menuItem = TestMenu.menuItem :create_site, title: 'Create Site'
+    menuItem.label.should.equal :create_site
+    menuItem.title.should.equal 'Create Site'
+  end
+
+  it "supports defining menu items with a block" do
+    menuItem = TestMenu.menuItem :create_site do |item|
+      item.title = 'Progress Item'
+    end
+
+    menuItem.title.should.equal 'Progress Item'
+  end
+
+  it "builds gives access to menu instance" do
+    TestMenu.menuItem :create_site, title: 'Create Site'
+    TestMenu.menu :main_menu, title: "Main"
+    menu = TestMenu[:main_menu]
+    menu.should.be.an.instance_of DrinkMenu::Menu
+  end
+
+  it "allows creating a top-level menu" do
+    menu = TestMenu.menu :main_menu, title: "Blah"
+    menu.menu.should.be.an.instance_of NSMenu
+    menu.title.should.equal "Blah"
+  end
+
+  it "allows creating a status bar menu item" do
+    menu = TestMenu.statusBarMenu :main_menu, title: "B"
+    menu.statusItemTitle.should.equal "B"
+
+    image = NSImage.imageNamed "NSMenuRadio"
+    menu = TestMenu.statusBarMenu :main_menu, icon: image
+    menu.statusItemIcon.should.equal image
+  end
+
+  it "evaluates menu's block to add items to menu" do
+    item1 = TestMenu.menuItem :test_item1, title: "Blah"
+    item2 = TestMenu.menuItem :test_item2, title: "Blah"
+
+    TestMenu.menu :main_menu, title: "Main" do
+      test_item1
+      ___
+      test_item2
+    end
+
+    TestMenu.build!
+
+    TestMenu[:main_menu][:test_item1].should.equal item1
+    TestMenu[:main_menu][:test_item2].should.equal item2
+
+    TestMenu[:main_menu][2].isSeparatorItem.should.be.true
+  end
+
+  describe "builder's context class" do
+
+    Context = DrinkMenu::MenuBuilder::Context
+
+    it "adds item to menu by calling method named after item's label" do
+      menu = DrinkMenu::Menu.new(:test)
+      item = DrinkMenu::MenuItem.itemWithLabel :test_item, title: "Blah"
+      context = Context.new(menu, {test_item: item})
+
+      menu[:test_item].should.be.nil
+
+      context.test_item
+
+      menu[:test_item].should.equal item
+    end
+
+    it "creates separators from ___" do
+      menu = DrinkMenu::Menu.new(:test)
+
+      menu[1].should.be.nil
+
+      Context.new(menu).send :"___"
+
+      puts menu.menuItems.inspect
+      menu[1].isSeparatorItem.should.be.true
+    end
+
+  end
+end

data/spec/menu_item_spec.rb

@@ -0,0 +1,82 @@
+describe "creating menu items" do
+
+  it "keeps the title and label" do
+    m = DrinkMenu::MenuItem.itemWithLabel :create_site, title: 'Create Site'
+    m.label.should.equal :create_site
+    m.title.should.equal 'Create Site'
+  end
+
+  it "allows passing a block for further configuration" do
+    m = DrinkMenu::MenuItem.itemWithLabel :export do |item|
+      item.title = 'Export...'
+    end
+
+    m.label.should.equal :export
+    m.title.should.equal 'Export...'
+  end
+
+  it "has an instance of NSMenuItem" do
+    m = DrinkMenu::MenuItem.itemWithLabel :create_site, title: 'Create Site'
+    m.menuItem.should.be.a.instance_of NSMenuItem
+  end
+
+  it "delegates NSMenuItem methods to NSMenuItem instance" do
+    m = DrinkMenu::MenuItem.itemWithLabel :create_site, title: 'Create Site'
+    m.enabled = false
+    m.tag = 1
+    m.image = NSImage.imageNamed "NSMenuRadio"
+    m.state = NSOnState
+
+    m.menuItem.title.should.equal m.title
+    m.menuItem.isEnabled.should.equal m.isEnabled
+    m.menuItem.tag.should.equal m.tag
+    m.menuItem.image.should.equal m.image
+    m.menuItem.state.should.equal m.state
+  end
+
+  it "exposes an RACCommand instance for subscribing" do
+    m = DrinkMenu::MenuItem.itemWithLabel :create_site, title: 'Create Site'
+    m.should.respond_to :subscribe
+    m.command.should.respond_to :execute
+    m.command.should.respond_to :subscribeNext
+  end
+
+  it "delegates subscribing to RACCommand" do
+    m = DrinkMenu::MenuItem.itemWithLabel :create_site, title: 'Create Site'
+    called = false
+    m.subscribe do |value|
+      value.should.equal [:create_site, m]
+      called = true
+    end
+    m.rac_command.execute(m.menuItem)
+    called.should.be.true
+  end
+
+  it "allows setting a canExecuteSignal on the RACCommand instance" do
+    m = DrinkMenu::MenuItem.itemWithLabel :create_site, title: 'Create Site'
+    signal = RACSubject.subject
+    m.canExecuteSignal = signal
+    m.subscribe do
+    end
+    signal.sendNext true
+    m.isEnabled.should.be.true
+    signal.sendNext false
+    m.isEnabled.should.be.false
+  end
+
+  it "allows creating separator items" do
+    item = DrinkMenu::MenuItem.separatorItem
+    item.isSeparatorItem.should.be.true
+  end
+
+  def separator_id(item)
+    item.label[/\d+$/].to_i
+  end
+
+  it "generates unique label for separators" do
+    item1 = DrinkMenu::MenuItem.separatorItem
+    item2 = DrinkMenu::MenuItem.separatorItem
+    separator_id(item2).should.equal separator_id(item1) + 1
+  end
+
+end

data/spec/menu_spec.rb

@@ -0,0 +1,195 @@
+describe "creating menus" do
+
+
+  it "creates an NSMenu instance" do
+    menu = DrinkMenu::Menu.new(:test)
+    menu.menu.should.be.an.instance_of NSMenu
+  end
+
+  it "forwards title to NSMenu instance" do
+    menu = DrinkMenu::Menu.menuWithLabel(:test_menu, title: "title")
+    menu.title.should.equal "title"
+    menu.menu.title.should.equal menu.title
+  end
+
+  it "automatically adds NSMenuItem instance to NSMenu" do
+    menu = DrinkMenu::Menu.new(:test)
+    item = DrinkMenu::MenuItem.itemWithLabel :test_item, title: "Blah"
+    menu << item
+
+    menu.itemArray.should.include item.menuItem
+
+  end
+
+  it "sets a unique tag on each menu item as it's added" do
+    menu = DrinkMenu::Menu.new(:test)
+    item1 = DrinkMenu::MenuItem.itemWithLabel :test_item1, title: "Blah"
+    item2 = DrinkMenu::MenuItem.itemWithLabel :test_item2, title: "Diddy"
+
+    menu << item1
+    menu << item2
+
+    item1.menuItem.tag.should.equal 1
+    item2.menuItem.tag.should.equal 2
+
+  end
+
+  describe "creating menu from collection of objects" do
+
+    class Person
+      attr_reader :firstName, :lastName
+
+      def initialize(firstName, lastName)
+        @firstName = firstName
+        @lastName = lastName
+      end
+
+      def fullName
+        "#{@firstName} #{@lastName}"
+      end
+
+      def inspect
+        "<#Person:#{hash} fullName=\"#{fullName}\">"
+      end
+    end
+
+    before do
+      @people = [Person.new("Joe", "Fiorini"), Person.new("Josh", "Walsh")]
+      @controller = NSArrayController.alloc.initWithContent(@people)
+      @menu = DrinkMenu::Menu.menuWithLabel :test, itemsFromCollection: @controller, titleProperty: :fullName
+    end
+
+    it "automatically creates menu items from each item" do
+      @menu.itemArray.length.should.equal 2
+    end
+
+    it "sets menu item titles using the property specified in titleProperty" do
+      @menu.itemArray.each_with_index do |item, idx|
+        item.title.should.equal @people[idx].fullName
+      end
+    end
+
+    it "supports arrays or array controllers"
+
+    it "sets menu item representedObject using the member" do
+      @menu.itemArray.each_with_index do |item, idx|
+        item.representedObject.should.equal @people[idx]
+      end
+    end
+
+    it "delegates menu command to menu items" do
+      handled = false
+
+      @menu.subscribeToMembers do |(label, _)|
+        label.should.equal :test
+        handled = true
+      end
+
+      @menu[1].command.execute @menu[1].menuItem
+      handled.should.be.true
+    end
+
+    it "automatically rebuilds the menu to reflect new members" do
+      @menu.itemArray.length.should.equal 2
+      newPerson = Person.new("Michael", "Bluth")
+      @controller.addObject(newPerson)
+      @menu.itemArray.length.should.equal 3
+      @menu.itemArray.should.any(&->(item){
+        item.representedObject == newPerson
+      })
+    end
+
+    it "sets up a subscriber for the new item" do
+      handled = false
+      newPerson = Person.new("Lucille", "Two")
+      @controller.addObject(newPerson)
+      @menu.subscribe newPerson.hash.to_s do |item|
+        handled = true
+      end
+      newItem = @menu[newPerson.hash.to_s]
+      newItem.command.execute(newItem)
+      handled.should.be.true
+    end
+
+    it "allows selecting an item by its member object" do
+      handled = false
+      @menu.subscribeToMembers do |(_,item)|
+        handled = true
+        item.representedObject.should.equal @people[0]
+      end
+
+      @menu.selectItemByMember @people[0]
+      handled.should.be.true
+    end
+
+  end
+
+  it "allows looking up menu items by label" do
+    menu = DrinkMenu::Menu.new(:test)
+    item = DrinkMenu::MenuItem.itemWithLabel :test_item, title: "Blah"
+
+    menu << item
+
+    menu[item.label].should.equal item
+  end
+
+  it "allows selecting an item by its label" do
+    handled = false
+    menu = DrinkMenu::Menu.new(:test)
+    item = DrinkMenu::MenuItem.itemWithLabel :test_item, title: "Blah"
+
+    menu << item
+
+    menu.subscribe :test_item do |_|
+      handled = true
+    end
+
+    menu.selectItem :test_item
+
+    handled.should.be.true
+  end
+
+  it "allows looking up menu items by tag" do
+    menu = DrinkMenu::Menu.new(:test)
+    item = DrinkMenu::MenuItem.itemWithLabel :test_item, title: "Blah"
+
+    menu << item
+
+    menu[1].should.equal item
+  end
+
+  it "supports wrapping menu in a status bar item" do
+    menu = DrinkMenu::Menu.statusMenuWithLabel :test, title: "S"
+    menu.createStatusItem!
+    menu.statusItem.should.be.an.instance_of NSStatusItem
+    menu.statusItem.highlightMode.should.be.true
+    menu.statusItem.title.should.equal "S"
+    menu.statusItem.menu.should.equal menu.menu
+  end
+
+  it "supports icon for status bar item" do
+    image = NSImage.imageNamed "NSMenuRadio"
+    menu = DrinkMenu::Menu.statusMenuWithLabel :test, icon: image
+    menu.createStatusItem!
+    menu.statusItem.image.should.equal image
+  end
+
+  it "supports subscribing to menu item commands" do
+    called = false
+
+    item = DrinkMenu::MenuItem.itemWithLabel :test_item, title: "Blah"
+    menu = DrinkMenu::Menu.new(:test)
+
+    menu << item
+
+    menu.subscribe :test_item do |(label, value)|
+      label.should.equal item.label
+      value.should.equal item
+      called = true
+    end
+
+    item.command.execute(item)
+    called.should.be.true
+  end
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: drink-menu
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joe Fiorini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.20.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.20.2
+description: An easy way to define menu items and visually lay out menus for your
+  OSX apps. Uses ReactiveCocoa to provide a nice syntax for responding to menu interactions.
+  Also provides live-binding to collections, which makes keeping menus up-to-date
+  a breeze!
+email:
+- joe@joefiorini.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- drink-menu.gemspec
+- lib/drink-menu.rb
+- lib/drink-menu/ext/forwardable.rb
+- lib/drink-menu/ext/ns_menu_item.rb
+- lib/drink-menu/menu.rb
+- lib/drink-menu/menu_builder.rb
+- lib/drink-menu/menu_item.rb
+- lib/drink-menu/version.rb
+- spec/menu_builder_spec.rb
+- spec/menu_item_spec.rb
+- spec/menu_spec.rb
+homepage: https://github.com/joefiorini/drink-menu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: OSX menus - the ruby way
+test_files:
+- spec/menu_builder_spec.rb
+- spec/menu_item_spec.rb
+- spec/menu_spec.rb