openmeta.rb 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2012-10-12
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,20 @@
+History.txt
+Manifest.txt
+README.md
+Rakefile
+bin/tag
+lib/openmeta.rb
+lib/openmeta/cli.rb
+lib/openmeta/framework/OpenMeta.framework/Headers
+lib/openmeta/framework/OpenMeta.framework/OpenMeta
+lib/openmeta/framework/OpenMeta.framework/Resources
+lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMeta.h
+lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMetaBackup.h
+lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMetaPrefs.h
+lib/openmeta/framework/OpenMeta.framework/Versions/A/OpenMeta
+lib/openmeta/framework/OpenMeta.framework/Versions/A/Resources/Info.plist
+lib/openmeta/framework/OpenMeta.framework/Versions/A/Resources/en.lproj/InfoPlist.strings
+lib/openmeta/framework/OpenMeta.framework/Versions/Current
+lib/openmeta/friendly_errors.rb
+lib/openmeta/ui.rb
+lib/openmeta/version.rb

data/README.md

@@ -0,0 +1,50 @@
+# openmeta.rb
+
+* https://github.com/zhaocai/openmeta.rb
+
+
+## DESCRIPTION:
+
+openMeta in Ruby (MacRuby, more exactly!)
+
+
+## SYNOPSIS:
+
+  Port openMeta api to macruby using framework.
+
+## REQUIREMENTS:
+
+* macruby
+* thor
+
+## INSTALL:
+
+* `gem install openmeta.rb`
+
+
+
+
+## DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+## LICENSE:
+
+Copyright (c) 2013 Zhao Cai <caizhaoff@gmail.com>
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+# require 'rake/distribute'
+
+Hoe.plugin :gemspec
+Hoe.plugin :git
+Hoe.plugin :test
+
+Hoe.spec 'openmeta.rb' do
+
+  developer('Zhao Cai', 'caizhaoff@gmail.com')
+
+  extra_deps << ['thor', '~> 0.17.0']
+end
+
+# distribute :FileItem do
+#   from "bin/openmeta"
+#   to   "/usr/local/bin/om", :mode => 0755
+# end
+
+bindir="/usr/local/bin"
+
+desc "install"
+task :install do
+  open("#{bindir}/om", "w") { |f|
+    f.puts "#!/bin/sh",
+      %Q{VM_OPT_LEVEL=0 macruby #{File.expand_path("bin/openmeta")} "$@"}
+  }
+  chmod 0755, "#{bindir}/om"
+end
+
+desc "uninstall"
+task :uninstall do
+  safe_unlink "#{bindir}/om"
+end
+
+# vim: syntax=ruby

data/bin/tag

@@ -0,0 +1,10 @@
+#!/usr/bin/env macruby
+
+($LOAD_PATH << File.expand_path("../../lib", __FILE__)).uniq!
+require 'rubygems' unless defined? Gem # rubygems is only needed in 1.8
+
+require 'openmeta'
+
+require 'openmeta/cli'
+require 'openmeta/friendly_errors'
+Openmeta.with_friendly_errors { Openmeta::CLI.start }

data/lib/openmeta/cli.rb

@@ -0,0 +1,110 @@
+require 'thor'
+require 'openmeta/ui'
+
+module Openmeta
+
+  class CLI < Thor
+
+    def initialize(*)
+      super
+      the_shell = (options["no-color"] || (not STDOUT.tty?) ? Thor::Shell::Basic.new : shell)
+      Openmeta.ui = UI::Shell.new(the_shell)
+      Openmeta.ui.debug! if options["verbose"]
+    end
+
+    desc "recent", "print recent tags"
+    method_option :format,
+      :aliases      => "-f"                  ,
+      :lazy_default => nil                   ,
+      :type         => :string               ,
+      :desc         => "print as yaml/plist"
+    def recent
+      tags = OpenMetaPrefs.recentTags
+
+      puts_to(options[:format], tags)
+    end
+
+    desc "clone", "clone openmeta tags and rating"
+    method_option :from,
+      :aliases  => "-f",
+      :required => true,
+      :type     => :string,
+      :desc     => "clone openmeta tags and rating from the FILE [required]"
+    def clone(file)
+      unless File.exist?(from_file)
+          raise Openmeta::PathError, "#{from_file} does not exist!"
+      end
+
+      tags = Openmeta.get_tags(from_file)
+      rating = Openmeta.get_rating(from_file)
+
+      Openmeta.set_tags(tags, file) unless tags.empty?
+      Openmeta.set_rating(rating, file) unless rating == 0.0
+    end
+
+
+    desc "get", "get openmeta tags and rating"
+    method_option :format,
+      :aliases      => "-f"                  ,
+      :lazy_default => nil                   ,
+      :type         => :string               ,
+      :desc         => "print as yaml/plist"
+    def get(file)
+
+      tags = {
+        :tags => Openmeta.get_tags(file),
+        :rating => Openmeta.get_rating(file)
+      }
+
+      puts_to(options[:format], tags)
+    end
+
+    desc "clear", "clear openmeta tags and rating"
+    def clear(file)
+      Openmeta.set_tags([], file)
+      Openmeta.set_rating(0.0, file)
+    end
+
+
+    desc "set", "set openmeta tags, use ',' to separate multiple tags"
+    method_option :tag,
+      :aliases      => "-t"       ,
+      :lazy_default => ''         ,
+      :type         => :string    ,
+      :desc         => "set tags, use ',' to separate multiple tags"
+    def set(file)
+      tags = options[:tag].split(',')
+      Openmeta.set_tags(tags, file)
+    end
+
+    desc "rate", "set openmeta rating"
+    method_option :rate,
+      :aliases      => "-r"       ,
+      :lazy_default => 0.0        ,
+      :type         => :numeric   ,
+      :desc         => "set rating"
+    def rate(file)
+      if options[:rate] > 5.0
+        raise RangeError, "rating is between [0.0 - 5.0]"
+      end
+      Openmeta.set_rating(options[:rate], file)
+    end
+
+  private
+    def puts_to(format, data)
+      unless format
+        puts data
+      else
+        require 'yaml' if format == 'yaml'
+        to_format = "to_#{format}"
+
+        begin
+          puts data.send(to_format)
+        rescue NoMethodError
+          raise Openmeta::NoMethodError, "#{to_format} has not implemented!"
+        end
+      end
+
+    end
+  end
+end

data/lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMeta.h

@@ -0,0 +1,250 @@
+//
+//  OpenMeta.h
+//  OpenMeta
+//
+//  Created by Tom Andersen on 17/07/08.
+//
+/*
+Copyright (c) 2009 ironic software
+
+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.
+*/
+
+#import <Cocoa/Cocoa.h>
+
+/*
+        Open Meta - why duplicate attributes that are already defined?
+        
+        To answer this, look at an example. kMDItemKeywords:
+        
+        When a file with keywords embedded in it is created or lands on the computer, say for example a PDF file, Spotlight
+        will import it. The keywords will be stored under kMDItemKeywords in the Spotlight DB. 
+        
+        Now a user wants to set keywords (ie tags) on a file - any file on their computer - whether or not
+        the file type supports keywords or not. If Open Meta used kMDItemKeywords to store these - it will work pretty well,
+        until the user stored their own tags, on that PDF file that already had embedded keywords. Then all sorts of problems happen:
+        1) The existing keywords are hidden from the user, as keywords set on the xattr will override the ones set in the meta data. 
+        2) These hidden keywords will come back when the file is viewed with Preview, or Acrobat, etc. 
+        3) If the keywords on the the file are changed inside Preview, then these changes will not show up in spotlight
+        
+        There are two solutions to this sort of problem. 
+        
+        One is to edit the 'actual keywords' inside the PDF. This solution quickly gets
+        complicated, as for each file type there may be none (eg: text file), one (eg:PDF), several (eg: jpeg, word?) 
+        places to store keywords, and the software to read and write keywords into all supported file types 
+        quickly grows to be unmanagable. The solution for text and other non keywordable files 
+        is to write the tags somewhere else (eg sidecar files). 
+        
+        The other solution is the tact taken by Open Meta. 
+        Keywords are written to their own tag, which is indexed by Spotlight, (kMDItemOMUserTags). 
+        These tags are independent of kMDItemkeywords. 
+        They can be written in the exact same very simple manner to each and every file on the file system. 
+        They do not hide the keywords set on the file. 
+        Since they are stored in xattrs, they can easily be included or excluded from a file, when 
+        that file is for instance shipped off to a third party. 
+        This is useful in order to keep metadata 'in house'. BUT - the data set by OpenMeta is not 'in the file' the same 
+        way that tags set on a jpeg are 'in' the EXIF portion of the file when bridge does it. 
+        The Open Meta tags follow the file around on the OS - through backups, copies and moves. 
+        
+		Other keys
+		----------------
+		 I used to consider it 'wrong' to be able to override kMDItem* stuff with OpenMeta, and it is for tags. Tags though are a special case,
+		 in that there could be for instance 6 keywords (relevant - ish) set on a PDF, and you want to add the open meta tag 'special' to it. You don't want to 
+		 lose the 6 keywords do you? There are also lots of images from image houses that have a lot of keyword 'noise' in them that you might not want
+		 cluttering up your tags that you have set. i have found png files with 50 keywords set. html can also be bad for this. So users want the ability to only look at tags that they have set,
+		 or a combination of keywords and tags.
+		 BUT - look at ratings - ratings are just one number - it is likely that you don't want to as a user, have to think about 2 different places ratings 
+		 could be stored, (like tags vs keywords), but would rather have just the one concept of 'rating'. It is also ok, even deisrable, to be able to override the rating
+		 on a file. So ratings _should_ use kMDItemStarRating.
+		 Also look at 'less used' keys - like camera (kMDItemAcquisitionMake and  kMDItemAcquisitionModel) - although they will be set on perhaps thousands of photos in 
+		 what if you run into a PDF that is a picture taken with a camera, and you want to tag that? openmeta will allow you to to tag it with kMDItemAcquisitionMake and kMDItemAcquisitionModel
+		 so that searches for camera make an model do not have to 'know about openmeta' to work. 
+		 Plus it's always good to keep the number of keys down.
+      
+        What about namespaces?
+        ----------------------
+        Open Meta is a clean simple way to set user entered searchable metadata on any file on Mac OS X. 
+        Concepts like namespaces are not encouraged, as most users have no idea what a namespace is. The tradeoff is a 
+        small amount of _understandable_ ambiguity - searching for Tags:apple (i.e. kMDItemOMUserTags == "apple"cd) will find
+        all files having to do with both the fruit one can eat, and the company that makes computers. Users expect this. 
+        With namespaces an improperly constructed query will usually result in 'no matches'. 
+*/
+
+
+/*
+    Note on Backup.
+	
+	Whenever you set an item with kMDItemOM* as the key, openmeta will make sure that there is a backup made of the tags, etc, that 
+	you have set on the file. The backups go into the folder ~/Library/Application Support/OpenMeta/backups.noindex/2009 etc. The backups are
+	one file per item, and are on a month by month basis. This may be all the backup you need, as time machine will back these up.
+	The .noindex suffix on the backup folder stops Spotlight from indexing the files.
+	
+    Note on Backup - "Time Machine", etc.
+    When you set an xattr on a file, the modification date on the file is NOT changed, 
+    but something called the status change time - does change.
+    Time Machine, however, will only back up on modified time changes - i.e. it only looks at st_mtimespec, ignoring st_ctimespec. 
+    This is a deliberate decision on TimeMachine's part.
+    So if you want your xattrs backed up - you need to set the modifcation date on the file to a newer date - utimes() is the call for this. 
+    It may be that you do not want to change the file modification date for each OpenMeta item that you write. If you do change the modification date, 
+    it may make sense to not change it 'by much' - thus preserving most of the 
+    meaning of the modification date, while still allowing TimeMachine to back the file up.
+*/
+
+
+// OpenMeta: Open metadata format for OS X. Data is stored in xattr.
+// Some items are reflected in the Spotlight Database, others not. 
+// ---------------------
+// This system allows someone to set metadata on a file, and have that metadata searchable in spotlight.
+// Several open meta keys are defined: See the schema.xml file in the OpenMeta spotlight plugin for the complete list.
+// 
+// User Entered Tags: Tags that users have added for workflow and organizational reasons. 
+//
+// Bookmarks: URLs associated with a document
+// 
+// Workflow: people, companies, etc that are in the workflow for this document
+//
+// Projects: Projects that this file is relevant to
+
+// on success return nil error
+// If setting/getting user tags failed we return a negative error code for one of our errors, or the error code from the underlying api (setxattr)
+// If there is errno set after a call we return that. errno codes seem to be positive numbers
+// We use NSError, and you can pass in nil if you are not interested in an error.
+#define OM_ParamError (-1)
+#define OM_NoDataFromPropertyListError (-2)
+#define OM_NoMDItemFoundError (-3)
+#define OM_CantSetMetadataError (-4)
+#define OM_MetaTooBigError (-5)
+// A very common errno error code is ENOATTR - the attribute is not set on the file. - which we don't consider an error
+
+extern NSString* const kMDItemOMUserTags;
+extern NSString* const kMDItemOMUserTagTime;
+extern NSString* const kMDItemOMDocumentDate;
+extern NSString* const kMDItemOMBookmarks; // list of urls - bookmarks as nsarray nsstring 
+extern NSString* const kMDItemOMUserTagApplication;
+
+extern const double kMDItemOMMaxRating;
+
+// kMDItemKeywords
+@interface OpenMeta : NSObject {
+
+}
+
+// User tags - an array of tags as entered by the user. This is not the place to 
+// store program generated gook, like GUIDs or urls, etc.
+// It is not nice to erase tags that are already set (unless the user has deleted them using your UI)
+// so ususally you would do a getUserTags, then merge/edit/ etc, followed by a setUserTags
+// Tags - NSStrings - conceptually utf8 - any characters allowed, spaces, commas, etc.
+// Case sensitive or not? Case preserving. Order of tags is not guaranteed, but it is attempted.
+// setUserTags will remove duplicates from the array, using case preserving rules. 
++(NSError*)setUserTags:(NSArray*)tags path:(NSString*)path;
++(NSArray*)getUserTags:(NSString*)path error:(NSError**)error;
++(NSError*)addUserTags:(NSArray*)tags path:(NSString*)path;
++(NSError*)clearUserTags:(NSArray*)tags path:(NSString*)path;
+
+
+// To change tags on groups of files: 
+// You first obtain the common tags in a list of files, 
+// then edit those common tags, then set the changes
+// you need to pass in the original common tags when writing the new tags out, 
+// so that we can be sure we are not overwriting other changes made by other users, etc 
+// during the edit cycle:
+// These calls are case preserving and case insensitive. So Apple and apple will both be the 'same' tag on reading
++(NSError*)setCommonUserTags:(NSArray*)paths originalCommonTags:(NSArray*)originalTags replaceWith:(NSArray*)newTags;
++(NSArray*)getCommonUserTags:(NSArray*)paths error:(NSError**)error;
+
+
+// Ratings are 0 - 5 stars. Setting a rating to 0 is the same as having no rating. 
+// rating is 0 - 5 floating point, so you have plenty of room. I clamp 0 - 5 on setting it.
+// passing 0 to setRating removes the rating. Also I return 0 if I can't find a rating.
+// Users have a hard time conceptualizing the difference between having no rating set and a rating of 0
++(NSError*)setRating:(double)rating05 path:(NSString*)path;
++(double)getRating:(NSString*)path error:(NSError**)error;
+
+// simplest way to set metadata that will be picked up by spotlight:
+// The string will be stored in the spotlight datastore. Likely you will not want 
+// to set large strings with this, as it will be hard on the spotlight db.
++(NSError*)setString:(NSString*)string keyName:(NSString*)keyName path:(NSString*)path;
++(NSString*)getString:(NSString*)keyName path:(NSString*)path error:(NSError**)error;
+
++(NSError*)setNumber:(NSNumber*)number keyName:(NSString *)keyName path:(NSString *)path;
++(NSNumber *)getNumber:(NSString*)keyName path:(NSString*)path error:(NSError**)error;
+
++(NSError*)setBoolValue:(BOOL)boolValue keyName:(NSString *)keyName path:(NSString *)path;
++(BOOL)getBoolValue:(NSString*)keyName path:(NSString*)path error:(NSError**)error;
+
++(NSError*)setDate:(NSDate *)date keyName:(NSString *)keyName path:(NSString *)path;
++(NSDate *)getDate:(NSString*)keyName path:(NSString*)path error:(NSError**)error;
+
++(NSError*)setData:(NSData *)data keyName:(NSString *)keyName path:(NSString *)path;
++(NSData *)getData:(NSString*)keyName path:(NSString*)path error:(NSError**)error;
+
+
+// If you have a 'lot' (ie 200 bytes to 4k) to set as a metadata on a file, then what you want to do
+// is use the setDictionaries call. You organize your data in an array of dictionaries, 
+// and each dict will be put into the metadata store and NOT be indexed by spotlight. 
+// In each dictionary, you optionally set one item with the key @"name" and THAT information will be stored in the spotlight DB
+// Say you set keyName to 'kMDItemOMLastPrintedInfo', then there would be an xattr with the name 'kMDItemOMLastPrintedInfo' that is an array of nsdictionaries
+// AND an xattr set on the file with com.apple.metadata:kMDItemOMLastPrintedInfo' which will be an array of the 'names' from the dicts. 
+// the 'name' would usually be used for search purposes. Other data can be 'anything'
+
+
+// for meta data in arrays: The add call weeds out duplicates 
++(NSArray*)getNSArrayMetaData:(NSString*)metaDataKey path:(NSString*)path error:(NSError**)error;
++(NSError*)setNSArrayMetaData:(NSArray*)array metaDataKey:(NSString*)metaDataKey path:(NSString*)path;
++(NSError*)addToNSArrayMetaData:(NSArray*)itemsToAdd metaDataKey:(NSString*)metaDataKey path:(NSString*)path;
+
+
+// extended attributes:
+// These getters and setters are to set xattr data that will be read and indexed by spotlight
+// If you pass large amounts of data or objects like dictionaries that spotlght cannot index, results are undefined.
+// The only things that spotlight can handle (as far as I know) are small arrays and nsstrings, nsdates, and nsnumbers 
++(id)getXAttrMetaData:(NSString*)metaDataKey path:(NSString*)path error:(NSError**)error;
++(NSError*)setXAttrMetaData:(id)plistObject metaDataKey:(NSString*)metaDataKey path:(NSString*)path;
+
+// dictionaries:
+// Spotlight can't have dictionaries in it's database.
+// remember that. You can store dictionaries using getXAttrMetaDataNoSpotlightMirror, or just setXAttr
+
+
+// to set data with no spotlight mirror, use this. omKey is something like kMDItemOMSomeKeyThatsNotNeededInSpotlight
++(id)getXAttrMetaDataNoSpotlightMirror:(NSString*)omKey path:(NSString*)path error:(NSError**)error;
++(NSError*)setXAttrNoSpotlightMirror:(id)plistObject omKey:(NSString*)omKey path:(NSString*)path;
+
+// These getters and setters are to set xattr data that will be NOT read and indexed by spotlight - nor are openmeta time stamps set, nor is restore done on backup.
+// The passed plist object will be converted to data as a binary plist object. (plist object is for example an nsdictionary or nsarray)
+// You can pass data up to 4k (or close to that depending on how much the data takes up in binary plist format)
++(id)getXAttr:(NSString*)inKeyName path:(NSString*)path error:(NSError**)error;
++(NSError*)setXAttr:(id)plistObject forKey:(NSString*)inKeyName path:(NSString*)path;
+
+
+// utils
++(NSArray*)orderedArrayWithDict:(NSDictionary*)inTags sortHint:(NSArray*)inSortedItems;
+
+// this call makes sure that all the keys in the OpenMeta kMDItemOM group get seen by Spotlight, so that the associated strings.xml. strings.schema, etc can work.
++(void)registerUsualOMAttributes; // just call this on launch if you want to be sure. 
++(void)registerOMAttributes:(NSDictionary*)typicalAttributes forAppName:(NSString*)appName;
+
++(NSString*)spotlightKey:(NSString*)inKeyName;
++(NSString*)openmetaKey:(NSString*)inKeyName;
++(NSString*)openmetaTimeKey:(NSString*)inKeyName;
+
+@end

data/lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMetaBackup.h

@@ -0,0 +1,106 @@
+//
+//  OpenMetaBackup.h
+//  Fresh
+//
+//  Created by Tom Andersen on 26/01/09.
+//  Copyright 2009 __MyCompanyName__. All rights reserved.
+//
+
+#import <Cocoa/Cocoa.h>
+
+/*
+Backing up xattr:
+
+Extended Attributes are supposed to 'not dissapear' they are connected to a file. When a user does a 'save' on a file, the default unix and cocoa apis will 
+preserve all the xattrs. BUT there are applications (notably Adobe CS 4 products, like Photoshop) which do a save in such a way as to wipe out all xattrs on each file 
+at each save. Not good. Also when using tools like subversion, etc where files are downloaded from the internet, xattrs can be easily lost. 
+
+So OpenMeta makes a backup file for every edit to xattrs when using the API. 
+
+The exact details may change in the future, the idea though is that when we go to retrieve tags for a file, if we find no tags, we check to see if there is a 
+backup file we can restore from. If no backup file, then there really are no tags on the file. 
+
+The backups are stored in the home folder of the person who made the change to the file, in ~/Library/OpenMeta/backups.noindex. This works well for most usage scenarios, 
+but with network volumes or mobile volumes, it may be better to store the backups in a predetermined place on the volume.
+
+*/
+
+@interface OpenMetaBackup : NSObject {
+
+}
+
+// individual file handling:
+// ---------------------------
+
+// backup is called automatically each time you set any attribute with kMDItemOM*, so you actually don't have to call this.
++(void)backupMetadata:(NSString*)inPath;
+
+// restore is called for you ONLY on tags and ratings. If you are using OpenMeta and not using tags or ratings, you need to call this first, in case the 
+// OpenMeta data has been deleted by an application like Adobe Photoshop CS4 which removes all metadata on files.
++(void)restoreMetadata:(NSString*)inPath;
+
+
+// Restoring all metadata 
+// ---------------------------
+// call this to restore all backed up meta data. Call when? On every launch is likely too much. 
+// if you call to tell user when done (ie initiated from a menu command, or similar), then the process runs at full speed, putting up a dialog when done.
+// it does run in a thread, though..
++(void)restoreAllMetadataOnBackgroundThread:(BOOL)tellUserWhenDone;
+
+
+// live repair 
+// Adobe products in particular can erase all xattrs when performing a simple 'Save' on a file - yeuuch
+// Open Meta will only usually restore tags if a file is re-opened for tagging. This
+// thread attempts to repair the files as they are damaged
+// Right now i don't personally run this thread in any ironic apps, other than our 'OM fix' app.
++(void)startLiveRepairThread;
++(void)stopLiveRepairThread; // you can't start/stop the live repair 
+
+// upgrade to open meta kMDItemOM user tags.
++(void)upgradeOpenMetaTokMDItemOM;
+
+// shutting down OpenMeta backup and restore systems 
+// ---------------------------
+
+// call this on quit, to leave time for any restores to safely, possibly, partially finish
++(void)appIsTerminating;
+
+// for OpenMeta.m use
++(BOOL)attributeKeyMeansAutomaticBackup:(NSString*)attrName;
++(void)copyTagsFromOldKeyTokMDItemOMIfNeeded:(NSString*)inPath;
+
+// these calls are async and send a notification on main thread when they are done. 
++(void)backupMetadataToSingleFile:(NSArray*)inKeys toFile:(NSString*)toFile;
++(void)restoreMetadataFromSingleFile:(NSString*)inBackupFile;
+
+@end
+
+// class for single file bullk backup
+@interface OpenMetaBackupOperation : NSOperation
+{
+	NSString* singleFile;
+	NSArray* keysToSearch;
+	NSDictionary* returnDict;
+	BOOL writeFile;
+}
+
+@property (retain) NSString*  singleFile;
+@property (retain) NSArray*  keysToSearch;
+@property (retain) NSDictionary*  returnDict;
+@property  BOOL  writeFile;
+
+@end
+
+
+// class for converting from kOMUserTags to kMDItemOMUserTags
+// it actually erases no data, it just adds a few fields of new data
+@interface OpenMetaUpgradeOperation : NSOperation
+{
+	NSString* mdQueryString;
+	NSString* keyToSet;
+}
+@property (retain) NSString*  mdQueryString;
+@property (retain) NSString*  keyToSet;
+@end
+
+

data/lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMetaPrefs.h

@@ -0,0 +1,29 @@
+//
+//  OpenMetaPrefs.h
+//  adobeFix
+//
+//  Created by Tom Andersen on 24/04/09.
+//  Copyright 2009 __MyCompanyName__. All rights reserved.
+//
+
+#import <Cocoa/Cocoa.h>
+
+
+@interface OpenMetaPrefs : NSObject {
+
+}
+// prefs support - this allows a common set of recently entered tags to be kept:
+// recently entered tags support:
++ (NSArray*)recentTags;		// an array of NSStrings, sorted by most recently added at the top. Case preserved.
+
+// this call is how you maintain the list of recent tags. When a user edits a list of tags on a doc, pass in the originals as 'old' and the entire set of changed ones as new. 
++ (void)updatePrefsRecentTags:(NSArray*)oldTags newTags:(NSArray*)newTags;
+
+// To be really sure that the prefs loaded correctly for recentTags, you could call this, but calling it at each keystroke as someone types will likely get slow. 
+// note that it is automatically called every few seconds when you call recentTags, so you likely don't need to call this.
++ (void)synchPrefs;	
+
+// for app store, etc - you can set the prefs to use your own app only.. DONT call with .plist on the prefs file name..
++(void)setPrefsFile:(NSString*)prefsFileToUse;
+
+@end

data/lib/openmeta/framework/OpenMeta.framework/Versions/A/Resources/Info.plist

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>BuildMachineOSBuild</key>
+	<string>12C60</string>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>OpenMeta</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.openmeta.OpenMeta</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>OpenMeta</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>DTCompiler</key>
+	<string></string>
+	<key>DTPlatformBuild</key>
+	<string>4G2008a</string>
+	<key>DTPlatformVersion</key>
+	<string>GM</string>
+	<key>DTSDKBuild</key>
+	<string>12C37</string>
+	<key>DTSDKName</key>
+	<string>macosx10.8</string>
+	<key>DTXcode</key>
+	<string>0452</string>
+	<key>DTXcodeBuild</key>
+	<string>4G2008a</string>
+</dict>
+</plist>

data/lib/openmeta/friendly_errors.rb

@@ -0,0 +1,23 @@
+module Openmeta
+  def self.with_friendly_errors
+    begin
+      yield
+    rescue Openmeta::OpenmetaError => e
+      Openmeta.ui.error e.message
+      Openmeta.ui.debug e.backtrace.join("\n")
+      exit e.status_code
+    rescue Interrupt => e
+      Openmeta.ui.error "\nQuitting..."
+      Openmeta.ui.debug e.backtrace.join("\n")
+      exit 1
+    rescue SystemExit => e
+      exit e.status
+    rescue Exception => e
+      Openmeta.ui.error(
+        "Unfortunately, a fatal error has occurred. Please see the Openmeta \n" \
+        "troubleshooting documentation. Thanks!\n  #{e.inspect} #{e.backtrace.join("\n")}\n")
+      raise e
+    end
+  end
+end
+

data/lib/openmeta/ui.rb

@@ -0,0 +1,73 @@
+module Openmeta
+  class UI
+    def warn(message, newline = nil)
+    end
+
+    def debug(message, newline = nil)
+    end
+
+    def error(message, newline = nil)
+    end
+
+    def info(message, newline = nil)
+    end
+
+    def confirm(message, newline = nil)
+    end
+
+    def debug?
+      false
+    end
+
+    class Shell < UI
+      attr_writer :shell
+
+      def initialize(shell)
+        @shell = shell
+        @quiet = false
+        @debug = ENV['DEBUG']
+      end
+
+      def info(msg, newline = nil)
+        tell_me(msg, nil, newline) if !@quiet
+      end
+
+      def confirm(msg, newline = nil)
+        tell_me(msg, :green, newline) if !@quiet
+      end
+
+      def warn(msg, newline = nil)
+        tell_me(msg, :yellow, newline)
+      end
+
+      def error(msg, newline = nil)
+        tell_me(msg, :red, newline)
+      end
+
+      def be_quiet!
+        @quiet = true
+      end
+
+      def debug?
+        # needs to be false instead of nil to be newline param to other methods
+        !!@debug && !@quiet
+      end
+
+      def debug!
+        @debug = true
+      end
+
+      def debug(msg, newline = nil)
+        tell_me(msg, nil, newline) if debug?
+      end
+
+      private
+      # valimism
+      def tell_me(msg, color = nil, newline = nil)
+        newline.nil? ? @shell.say(msg, color) : @shell.say(msg, color, newline)
+      end
+    end
+
+  end
+end
+

data/lib/openmeta/version.rb

@@ -0,0 +1,4 @@
+module Openmeta
+  VERSION = '1.0.0'
+end
+

data/lib/openmeta.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env macruby
+# -*- coding: utf-8 -*-
+
+def is_macruby?
+  begin
+    MACRUBY_VERSION
+    return true
+  rescue
+    return false
+  end
+end
+
+if is_macruby?
+  ($LOAD_PATH << File.expand_path("../openmeta/framework", __FILE__)).uniq!
+  framework "OpenMeta"
+else
+  raise NotImplementedError, "[Openmeta] only work with macruby"
+end
+
+require 'openmeta/version'
+require 'openmeta/ui'
+module Openmeta
+  class OpenmetaError < RuntimeError
+    def self.status_code(code)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class ObjCError           < OpenmetaError; status_code(1) ; end
+  class RangeError          < OpenmetaError; status_code(2) ; end
+  class NoMethodError       < OpenmetaError; status_code(13) ; end
+  class PathError           < OpenmetaError; status_code(14) ; end
+  class DslError            < OpenmetaError; status_code(15) ; end
+
+
+  class << self
+    attr_writer :ui, :error
+
+    def ui
+      @ui ||= UI.new
+    end
+
+    def error
+      @error ||= error = Pointer.new(:id)
+    end
+
+    def get_tags(path)
+      tags = OpenMeta.getUserTags(File.expand_path(path), error:error)
+      if error.value
+        raise Openmeta::ObjCError, error.value.inspect
+      end
+      tags
+    end
+
+    def set_tags(tags, path)
+      e = OpenMeta.setUserTags(tags, path:File.expand_path(path))
+      if e
+        raise Openmeta::ObjCError, e.inspect
+      end
+    end
+
+    def get_rating(path)
+      rating = OpenMeta.getRating(File.expand_path(path), error:error)
+      if error.value
+        raise Openmeta::ObjCError, error.value.inspect
+      end
+      rating
+    end
+
+    def set_rating(rating, path)
+      e = OpenMeta.setRating(rating, path:File.expand_path(path))
+      if e
+        raise Openmeta::ObjCError, e.inspect
+      end
+    end
+
+  end
+
+end
+
+
+

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: openmeta.rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Zhao Cai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: openMeta in Ruby (MacRuby, more exactly!)
+email:
+- caizhaoff@gmail.com
+executables:
+- tag
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+files:
+- History.txt
+- Manifest.txt
+- README.md
+- Rakefile
+- bin/tag
+- lib/openmeta.rb
+- lib/openmeta/cli.rb
+- lib/openmeta/framework/OpenMeta.framework/OpenMeta
+- lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMeta.h
+- lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMetaBackup.h
+- lib/openmeta/framework/OpenMeta.framework/Versions/A/Headers/OpenMetaPrefs.h
+- lib/openmeta/framework/OpenMeta.framework/Versions/A/OpenMeta
+- lib/openmeta/framework/OpenMeta.framework/Versions/A/Resources/Info.plist
+- lib/openmeta/framework/OpenMeta.framework/Versions/A/Resources/en.lproj/InfoPlist.strings
+- lib/openmeta/friendly_errors.rb
+- lib/openmeta/ui.rb
+- lib/openmeta/version.rb
+homepage: https://github.com/zhaocai/openmeta.rb
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+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: openmeta.rb
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: openMeta in Ruby (MacRuby, more exactly!)
+test_files: []