everyday-menu 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20e76b11c441473e0e4ab83add9a4eb6692db4a0
-  data.tar.gz: b872cab667104743fae5236aa71631d715398ed6
+  metadata.gz: 8629e47d2c83c578b36c97f19929b19510a2f109
+  data.tar.gz: 33d50f3c20d86ade4efb059ca5c540ec8fc3fd5e
 SHA512:
-  metadata.gz: c26e264bf9182b13d4034f0e4120715f52e01b4f1d94506aa0acd0bd52f6772370071771f2b06baacdc52550a1c6c6f0de2d359eb629731c203892fa60a0870f
-  data.tar.gz: d1981839333e795fb6f50fa53b43d5e3ae7cba8f3f8e7143bd01b4e887ee2c2b4aba73b770d699a1a5f64c918d06a67f5b45bc3c1e463960a6ff11ad936a4401
+  metadata.gz: d52d5545f858e73378246066a05eb524fab4363eacc03cba1876d80e9c5b6f58a86342c2736884b9313a85d0a3ce49645da321bb7df7f1a45c3ae52199e8e2e3
+  data.tar.gz: 4cfac1436396e77297c61d1745eab23bbb455baa64b184146fa73310b1c599de978887be0ed59f62ab10a7a04e05a8d5f9103ddc213440474019bba0aed4cdcc

data/.gitignore

@@ -0,0 +1,23 @@
+*.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
+
+/.idea/
+
+/projectFilesBackup/

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,24 @@
+Here is the copyright from drink-menu, which I based a lot of my code on:
+
+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,75 @@
+# EverydayMenu
+
+## Credit
+Please note that this gem is strongly based off of Joe Fiorini's `drink-menu` gem (with a little code copy-paste and lots of test and readme copy-paste), which I couldn't get to work for me.
+
+You can find his gem at <https://github.com/joefiorini/drink-menu>.  He doesn't get all of the credit, but he gets a lot of it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'everyday-menu'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install everyday-menu
+
+## Usage
+
+Everyday Menu separates menu layout from menu definition. Menu definition looks like:
+
+
+```ruby
+class MainMenu
+  extend EverydayMenu::MenuBuilder
+
+  menuItem :create_site, 'Create Site'
+  menuItem :export, 'Export to Folder...'
+  menuItem :import, 'Import Folder as Site...'
+  menuItem :force_rebuild, 'Force Rebuild'
+  menuItem :about, 'About Staticly'
+  menuItem :quit, 'Quit', key_equivalent: 'q'
+end
+```
+
+and then layout is as simple as:
+
+```ruby
+
+class MainMenu
+  extend EverydayMenu::MenuBuilder
+
+  mainMenu :main_menu, 'Main Menu' do
+    create_site
+    ___
+    export
+    import
+    force_rebuild
+    ___
+    about
+    quit
+  end
+end
+```
+
+## Running the Examples
+
+To run our example apps:
+
+1. Clone this repo
+2. From within your clone's root, run `platform=osx example=basic_main_menu rake`
+
+You can replace the value of `example` with any folder under the `examples` directory to run that example.
+
+## 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,24 @@
+$:.unshift('/Library/RubyMotion/lib')
+
+if ENV['platform'] == 'osx'
+  require 'motion/project/template/osx'
+else
+  raise 'The everyday-menu gem must be used within an OSX project.'
+end
+
+begin
+  require 'bundler'
+  Bundler.require
+rescue LoadError
+# ignored
+end
+
+Motion::Project::App.setup do |app|
+  app.name       = 'everyday-menu'
+  app.identifier = 'us.myepg.everyday-menu'
+  app.specs_dir  = 'spec/'
+
+  if ENV['example']
+    app.files << Dir["examples/#{ENV['example']}/**/*.rb"]
+  end
+end

data/everyday-menu.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'everyday-menu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'everyday-menu'
+  spec.version       = EverydayMenu::VERSION
+  spec.authors       = ['Eric Henderson']
+  spec.email         = ['henderea@gmail.com']
+  spec.description   = %q{An easy way to define menu items and visually lay out menus for your OSX apps. Based strongly on the drink-menu gem that I couldn't get to work for me.}
+  spec.summary       = %q{A more ruby way to create OS X menus in RubyMotion}
+  spec.homepage      = 'https://github.com/henderea/everyday-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'
+end

data/examples/basic_main_menu/app_delegate.rb

@@ -0,0 +1,24 @@
+class AppDelegate
+
+  def applicationDidFinishLaunching(notification)
+    MainMenu.build!
+
+    MainMenu[:app].subscribe :quit do |_|
+      NSApp.terminate(self)
+    end
+
+    MainMenu[:file].subscribe :new do |_|
+      puts 'new'
+    end
+
+    MainMenu[:file].subscribe :close do |_|
+      puts 'close'
+    end
+
+    MainMenu[:file].subscribe :open do |_|
+      puts 'open'
+    end
+
+  end
+
+end

data/examples/basic_main_menu/main_menu.rb

@@ -0,0 +1,20 @@
+class MainMenu
+  extend EverydayMenu::MenuBuilder
+
+  menuItem :quit, 'Quit', key_equivalent: 'q'
+  menuItem :open, 'Open', key_equivalent: 'o'
+  menuItem :new, 'New'
+
+  menuItem :close, 'Close', key_equivalent: 'w'
+
+  mainMenu :app, 'Blah' do
+    quit
+  end
+
+  mainMenu :file, 'File' do
+    new
+    open
+    ___
+    close
+  end
+end

data/lib/everyday-menu.rb

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

data/lib/everyday-menu/menu.rb

@@ -0,0 +1,152 @@
+module EverydayMenu
+  class Menu
+    attr_reader :needsMenuItem
+
+    def self.create(label, title, options = {}, &block)
+      new(label, &block).tap { |menu|
+        menu[:label] = label
+        menu[:title] = title
+        options.each { |option| menu[option[0]] = option[1] }
+      }
+    end
+
+    def initialize(label, &block)
+      @label         = label
+      @builder       = block
+      @menu          = NSMenu.alloc.init
+      @menuItems     = MenuItemList.new(@menu)
+      @needsMenuItem = false
+    end
+
+    def menuItemFromMenu!
+      @mainMenuItem ||= MenuItem.create(self[:label], self[:title], submenu: self)
+      self
+    end
+
+    alias :menu_item_for_menu! :menuItemFromMenu!
+
+    def menuItem
+      @mainMenuItem.item
+    end
+
+    alias :menu_item :menuItem
+
+    def subscribe(label, &block)
+      self.items[label].subscribe(&block)
+    end
+
+    def <<(item)
+      @menuItems << item
+    end
+
+    def has(key)
+      name = key_to_name(key, 'has')
+      begin
+        self.send(name)
+      rescue NoMethodError
+        @menu.send(name)
+      end
+    end
+
+    def is(key)
+      name = key_to_name(key, 'is')
+      begin
+        self.send(name)
+      rescue NoMethodError
+        @menu.send(name)
+      end
+    end
+
+    def [](key)
+      name = key_to_name(key)
+      begin
+        self.send(name)
+      rescue NoMethodError
+        @menu.send(name)
+      end
+    end
+
+    def []=(key, value)
+      name = key_to_name(key, 'set')
+      begin
+        self.send(name, value)
+      rescue NoMethodError
+        @menu.send(name, value)
+      end
+    end
+
+    def key_to_name(key, prefix = nil)
+      rval = key.to_s.gsub(/_(\w)/) { |_| $1.upcase }
+      prefix.nil? ? rval : "#{prefix}#{rval[0].upcase}#{rval[1..-1]}"
+    end
+
+    def label
+      @label ||= nil
+    end
+
+    def setLabel(label)
+      @label = label
+    end
+
+    alias :label= :setLabel
+
+    def items
+      @menuItems
+    end
+
+    def menu
+      @menu
+    end
+
+    def builder
+      @builder
+    end
+
+    def isMainMenu
+      @needsMenuItem
+    end
+
+    alias :mainMenu :isMainMenu
+    alias :main_menu? :isMainMenu
+
+    def setMainMenu(value)
+      @needsMenuItem = value
+    end
+
+    alias :main_menu= :setMainMenu
+  end
+
+  class MenuItemList
+    def initialize(menu)
+      @menuItems = {}
+      @menu      = menu
+    end
+
+    def <<(item)
+      previousItemTag        = @menuItems.keys.last || 0
+      item[:tag]             = previousItemTag + 1
+      @menuItems[item[:tag]] = item
+      @menu.addItem item.menuItem
+    end
+
+    def [](labelOrTag)
+      (labelOrTag.is_a? Fixnum) ? @menuItems[labelOrTag] : @menuItems.values.find { |item| item.label == labelOrTag }
+    end
+
+    def selectItem(label)
+      item = self[label]
+      item.execute
+    end
+
+    alias :select_item :selectItem
+
+    def selectItemByMember(member)
+      item = @menuItems.values.find do |i|
+        i[:represented_object] == member
+      end
+      item.execute
+    end
+
+    alias :select_item_by_member :selectItemByMember
+  end
+end

data/lib/everyday-menu/menu_builder.rb

@@ -0,0 +1,70 @@
+module EverydayMenu
+  module MenuBuilder
+    class Context < BasicObject
+      def initialize(menu, menuItems={})
+        @menu      = menu
+        @menuItems = menuItems
+      end
+
+      def ___
+        @menu << MenuItem.separator
+      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, options = {})
+      options[:submenu] = @menus[options[:submenu]] if options.has_key?(:submenu)
+      self << MenuItem.create(label, title, options)
+    end
+
+    alias :menu_item :menuItem
+
+    def mainMenu(label, title, options = {}, &block)
+      options[:main_menu] = true
+      @menus              ||= {}
+      @menus[label]       = Menu.create(label, title, options, &block)
+    end
+
+    alias :main_menu :mainMenu
+
+    def menu(label, title, options = {}, &block)
+      options[:main_menu] = false
+      @menus              ||= {}
+      @menus[label]       = Menu.create(label, title, options, &block)
+    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.is :main_menu
+          @mainMenu ||= NSMenu.new
+          @mainMenu.addItem menu.menuItemFromMenu!.menuItem
+        end
+      end
+      setupMainMenu if @mainMenu
+    end
+
+    private
+
+    def setupMainMenu
+      NSApp.mainMenu = @mainMenu
+    end
+  end
+end

data/lib/everyday-menu/menu_item.rb

@@ -0,0 +1,123 @@
+module EverydayMenu
+  class MenuItem
+    def self.create(label, title, options = {})
+      new.tap { |item|
+        item[:label] = label
+        item[:title] = title
+        options.each { |option| item[option[0]] = option[1] }
+      }
+    end
+
+    def self.separator
+      @@separatorId ||= 0
+      @@separatorId += 1
+      label         = :"separator#{@@separatorId}"
+      new(NSMenuItem.separatorItem).tap do |item|
+        item.label = label
+      end
+    end
+
+    def self.separatorItem
+      self.separator
+    end
+
+    def initialize(menuItem=nil)
+      @menuItem = menuItem || NSMenuItem.alloc.init
+    end
+
+    def has(key)
+      name = key_to_name(key, 'has')
+      begin
+        self.send(name)
+      rescue NoMethodError
+        @menuItem.send(name)
+      end
+    end
+
+    def is(key)
+      name = key_to_name(key, 'is')
+      begin
+        self.send(name)
+      rescue NoMethodError
+        @menuItem.send(name)
+      end
+    end
+
+    def [](key)
+      name = key_to_name(key)
+      begin
+        self.send(name)
+      rescue NoMethodError
+        @menuItem.send(name)
+      end
+    end
+
+    def []=(key, value)
+      name = key_to_name(key, 'set')
+      begin
+        self.send(name, value)
+      rescue NoMethodError
+        @menuItem.send(name, value)
+      end
+    end
+
+    def key_to_name(key, prefix = nil)
+      rval = key.to_s.gsub(/_(\w)/) { |_| $1.upcase }
+      prefix.nil? ? rval : "#{prefix}#{rval[0].upcase}#{rval[1..-1]}"
+    end
+
+    def setSubmenu(menu)
+      @menuItem.submenu = menu.menu
+    end
+
+    def menuItem
+      @menuItem
+    end
+
+    alias :menu_item :menuItem
+    alias :item :menuItem
+
+    def label
+      @label ||= nil
+    end
+
+    def setLabel(label)
+      @label = label
+    end
+
+    alias :label= :setLabel
+
+    def tag
+      @menuItem.tag
+    end
+
+    def setTag(tag)
+      @menuItem.tag = tag
+    end
+
+    alias :tag= :setTag
+
+    def subscribe(&block)
+      @menuItem.subscribe(&block)
+    end
+
+    def execute
+      @menuItem.runBlock(self)
+    end
+  end
+end
+
+class NSMenuItem
+  def subscribe(&block)
+    @blocks ||= []
+    @blocks << block
+    return if (self.target = self && self.action == :'runBlocks:')
+    @original_target = self.target
+    self.target      = self
+    self.action      = :'runBlock:'
+  end
+
+  def runBlock(sender)
+    @blocks.each { |block| block.call(sender) } unless @blocks.nil?
+  end
+end

data/lib/everyday-menu/version.rb

@@ -0,0 +1,3 @@
+module EverydayMenu
+  VERSION = '0.1.1'
+end

data/spec/menu_builder_spec.rb

@@ -0,0 +1,105 @@
+class TestMenu;
+  extend EverydayMenu::MenuBuilder;
+end
+class TestMenu2;
+  include EverydayMenu::MenuBuilder;
+end
+
+describe 'sugar for creating menus' do
+
+  it 'supports defining menu items' do
+    menuItem = TestMenu.menuItem :create_site, 'Create Site'
+    menuItem[:label].should.equal :create_site
+    menuItem[:title].should.equal 'Create Site'
+  end
+
+  it 'builds gives access to menu instance' do
+    TestMenu.menuItem :create_site, 'Create Site'
+    TestMenu.menu :main_menu, 'Main'
+    menu = TestMenu[:main_menu]
+    menu.should.be.an.instance_of EverydayMenu::Menu
+  end
+
+  it 'allows creating a top-level menu' do
+    menu = TestMenu.menu :main_menu, 'Blah'
+    menu.menu.should.be.an.instance_of NSMenu
+    menu[:title].should.equal 'Blah'
+  end
+
+  it 'evaluates menu\'s block to add items to menu' do
+    builder = TestMenu2.new
+    item1   = builder.menuItem :test_item1, 'Blah'
+    item2   = builder.menuItem :test_item2, 'Blah'
+
+    builder.menu :main_menu, 'Main' do
+      test_item1
+      ___
+      test_item2
+    end
+
+    builder.build!
+
+    builder[:main_menu][:test_item1].should.equal item1
+    builder[:main_menu][:test_item2].should.equal item2
+
+    builder[:main_menu][2].is(:separator_item).should.be.true
+  end
+
+  it 'supports generating an NSApp\'s mainMenu items' do
+    builder   = TestMenu2.new
+    testItem1 = builder.menuItem :test_item1, 'Blah 1'
+    testItem2 = builder.menuItem :test_item2, 'Blah 2'
+
+    menu1 = builder.mainMenu :menu1, 'Menu 1' do
+      test_item1
+    end
+
+    menu2 = builder.mainMenu :menu2, 'Menu 2' do
+      test_item2
+    end
+
+    builder.build!
+
+    mainMenu = NSApp.mainMenu
+
+    menuItem = mainMenu.itemArray[0]
+    puts "menu1 title: #{menu1.title.inspect}"
+    puts "menuItem title: #{menuItem.title.inspect}"
+    menuItem.title.should.equal menu1[:title]
+    menuItem.submenu.title.should.equal menu1[:title]
+    menuItem.submenu.itemArray[0].title.should.equal('Blah 1')
+
+    menuItem = mainMenu.itemArray[1]
+    menuItem.title.should.equal menu2[:title]
+    menuItem.submenu.title.should.equal menu2[:title]
+    menuItem.submenu.itemArray[0].title.should.equal('Blah 2')
+  end
+
+  describe 'builder\'s context class' do
+
+    Context = EverydayMenu::MenuBuilder::Context
+
+    it 'adds item to menu by calling method named after item\'s label' do
+      menu    = EverydayMenu::Menu.create :test, 'Test'
+      item    = EverydayMenu::MenuItem.create :test_item, '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 = EverydayMenu::Menu.create :test, 'Test'
+
+      menu[1].should.be.nil
+
+      Context.new(menu).__send__ :'___'
+
+      menu[1].is[:separator_item].should.be.true
+    end
+
+  end
+end

data/spec/menu_item_spec.rb

@@ -0,0 +1,38 @@
+describe 'creating menu items' do
+
+  it 'keeps the title and label' do
+    m = EverydayMenu::MenuItem.create :create_site, 'Create Site'
+    m[:label].should.equal :create_site
+    m[:title].should.equal 'Create Site'
+  end
+
+  it 'has an instance of NSMenuItem' do
+    m = EverydayMenu::MenuItem.create :create_site, 'Create Site'
+    m.menuItem.should.be.a.instance_of NSMenuItem
+  end
+
+  it 'allows extra options to create method' do
+    m = EverydayMenu::MenuItem.create :create_site, 'Create Site', enabled: false, tag: 1, 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 'allows creating separator items' do
+    item = EverydayMenu::MenuItem.separatorItem
+    item.is(:separator_item).should.be.true
+  end
+
+  def separator_id(item)
+    item.label[/\d+$/].to_i
+  end
+
+  it 'generates unique label for separators' do
+    item1 = EverydayMenu::MenuItem.separatorItem
+    item2 = EverydayMenu::MenuItem.separatorItem
+    separator_id(item2).should.equal separator_id(item1) + 1
+  end
+
+end

data/spec/menu_spec.rb

@@ -0,0 +1,70 @@
+describe 'creating menus' do
+
+
+  it 'creates an NSMenu instance' do
+    menu = EverydayMenu::Menu.create :test, 'Test'
+    menu.menu.should.be.an.instance_of NSMenu
+  end
+
+  it 'sets title on NSMenu instance' do
+    menu = EverydayMenu::Menu.create :test_menu, 'title'
+    menu[:title].should.equal 'title'
+    menu.menu.title.should.equal menu[:title]
+  end
+
+  it 'automatically adds NSMenuItem instance to NSMenu' do
+    menu = EverydayMenu::Menu.create :test, 'Test'
+    item = EverydayMenu::MenuItem.create :test_item, 'Blah'
+    menu << item
+
+    menu[:item_array].should.include item.menuItem
+
+  end
+
+  it 'sets a unique tag on each menu item as it is added' do
+    menu  = EverydayMenu::Menu.create :test, 'Test'
+    item1 = EverydayMenu::MenuItem.create :test_item1, 'Blah'
+    item2 = EverydayMenu::MenuItem.create :test_item2, 'Diddy'
+
+    menu << item1
+    menu << item2
+
+    item1.menuItem.tag.should.equal 1
+    item2.menuItem.tag.should.equal 2
+
+  end
+
+  it 'allows looking up menu items by label' do
+    menu = EverydayMenu::Menu.create :test, 'Test'
+    item = EverydayMenu::MenuItem.create :test_item, 'Blah'
+
+    menu << item
+
+    menu[item.label].should.equal item
+  end
+
+  it 'allows selecting an item by its label' do
+    handled = false
+    menu    = EverydayMenu::Menu.create :test, 'Test'
+    item    = EverydayMenu::MenuItem.create :test_item, '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 = EverydayMenu::Menu.create :test, 'Test'
+    item = EverydayMenu::MenuItem.create :test_item, 'Blah'
+
+    menu << item
+
+    menu[1].should.equal item
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: everyday-menu
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Eric Henderson
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 10.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 10.0.0
 description: An easy way to define menu items and visually lay out menus for your
   OSX apps. Based strongly on the drink-menu gem that I couldn't get to work for me.
 email:
@@ -45,7 +45,23 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- everyday-menu.gemspec
+- examples/basic_main_menu/app_delegate.rb
+- examples/basic_main_menu/main_menu.rb
+- lib/everyday-menu.rb
+- lib/everyday-menu/menu.rb
+- lib/everyday-menu/menu_builder.rb
+- lib/everyday-menu/menu_item.rb
+- lib/everyday-menu/version.rb
+- spec/menu_builder_spec.rb
+- spec/menu_item_spec.rb
+- spec/menu_spec.rb
 homepage: https://github.com/henderea/everyday-menu
 licenses:
 - MIT
@@ -70,5 +86,8 @@ rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A more ruby way to create OS X menus in RubyMotion
-test_files: []
+test_files:
+- spec/menu_builder_spec.rb
+- spec/menu_item_spec.rb
+- spec/menu_spec.rb
 has_rdoc: