Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
539 lines (328 sloc) 29.7 KB

Upcoming Version

Version 3.1.9

  • hanke: (server) Rewrite of “rake index” – Picky will only fork processes if there is the capability to fork (i.e. not Windows), or if there are more than one processor available.

Version 3.1.8

Version 3.1.7

Version 3.1.6

Version 3.1.5

  • hanke: (server) New Search block option: ignore_unassigned_tokens(truey/falsy). Default is false. If true, will ignore tokens that cannot be assigned to any category. If you search for example for "Picky Garblegarblegarble", and "Garblegarblegarble" isn’t in any index, then it will return result as if "Garblegarblegarble" hadn’t been there. In this case, it will just return something like searchengine:“picky”.

Version 3.1.4

  • hanke: (server) Don’t fork if there’s just one index to be processed.

Version 3.1.3

  • hanke: (server) Added #ignore option to Search definition block. Calling ignore :name will ignore tokens in allocations that are mapped to the name category. Example: You search for “David Hasselhoff”. If Picky maps this to allocations [ [:first_name, name], [:first_name, :movie_title] ], only [ [:first_name], [:first_name, :movie_title] ] will survive. The Hasselhoff - name match will simply be ignored.

Version 3.1.2

  • hanke: (generated client) The before Javascript callback option given to the PickyClient has changed signature and how it is called. Old was before(params, query), and the returned params changed the params. This did not allow changing the query in the callback. New is before(query, params) and the returned query replaces the query given as parameter. This allows changing the query before sending it off. The params can be changed as well, using params['option'] = value;.

Version 3.1.1

  • hanke: (server) rake index does not fork anymore if there’s just one index to be indexed.
  • hanke: (server) Experimental Picky::Partial::Infix partial generator. Use to find all possible substrings inside words. Options are min, max, both take negative and/or positive values. Negative values indicate length up to length – X. E.g. min: 3, max: -1 # :hello => [:hello, :hell, :ello, :hel, :ell, :llo]
  • hanke: (server) Experimental Picky::Backends::File file backend. Use in index definition block as follows: backend Use if you don’t want Picky to use as much memory. Performance penalty applies.

Version 3.1.0

  • hanke: (server) Exchangeable backends. New index definition: Indexes::Memory and Indexes::Redis are now unified in Index. So use index = from now on. (See next point)
  • hanke: (server) A new option has been added to the index, backend. It takes a backend instance, making the backend exchangeable. The default is the memory backend, which you do not need to set. If you want a Redis backend, use as follows: index = { backend }. If you want to explicitly set the memory backend: index = { backend }.
  • hanke: (server) Unified tokenizers. Method #tokenize(text) now returns [ ["token", "token", "token"], ["Original", "Original", "Original"] ]. So your own tokenizer only needs to adhere to this interface and can be passed to the index/search using the indexing/searching method.
  • hanke: (server) Removed tokenizer option removes_characters_after_splitting: /some regexp/ (without replacement).

Version 3.0.1

  • hanke: (server) Fixed & integration tested rake tasks (Thanks rogerbraun!)

Version 3.0.0

  • hanke: (client) Breaking: Removed method Picky::Convenience#allocations_size. Use #allocations.size.
  • hanke: (server) Breaking: Removed Results#to_log. Results#to_s returns a log worthy string now.
  • See changes in pre versions for complete changelog on 3.0.

Version 3.0.0.pre5

  • hanke: (server) Renamed Picky::Result#serialize → Picky::Result#to_hash.

Version 3.0.0.pre4

  • hanke: (generators) Added an All-In-One (Client + Server) Sinatra web app. This proves useful when wishing to use Picky on Heroku.

Version 3.0.0.pre3

  • hanke: (client) Gemfile referred to version ~> 2.0 instead of = 3.0.0.pre2.

Version 3.0.0.pre2

  • hanke: (server) Breaking: Index::Memory and Index::Redis do not accept options anymore.
Define options in the block or on the resulting instances some_index = do source … key_format … category … category … category … result_identifier … end
  • hanke: (server) Breaking: PickyLog removed.
In the classic server, use Picky.logger = ‘log/search.log’ if you want to log (uses SomeLogger#info). In the Sinatra server, use MyLogger = ‘log/search.log’ … get ‘/path’ do result = … result.to_log(params[:query]) if you want to log. result.to_json end
  • hanke: (server) Breaking: app/logging.rb not loaded anymore. You have to require it yourself if you want that.
  • hanke: (server) A missing source is only noticed when it is used (such as in indexing). This makes it possible to set a source at a later time.

Version 3.0.0.pre1

  • hanke: (server) Note: The key_format is not saved in the index configuration anymore.
  • hanke: (generator) New example server, sinatra_server. The new default, very flexible.

Version 2.7.0

  • hanke: (server) Breaking: Method #take_snapshot removed from Indexes/Index/Category (not needed anymore).
  • hanke: (server) Breaking: Users need to reindex when installing this version (index “index” now identified by “inverted” to be more clear).
  • hanke: (server) Rake tasks rewritten to be simpler and clearer. Most notably, index:specific[index,category] is now just index[index,category] (both optional).
  • hanke: (server) Reindexing now possible in running server, also for ActiveRecord Arel sources.
  • hanke: (server) More verbose indexing output with file locations.
  • hanke: (server) Taking data snapshots improved.
  • hanke: (client) Fix for e.g. picky search localhost:8080/books if highline gem is missing (thanks tonini!).

Version 2.6.0

  • hanke: (server) Breaking: Indexes#find method has been removed. Use Indexes[index_name] and Indexes[index_name][category_name].
  • hanke: (server) Breaking: Index#index!, Index#cache!, Category#index!, Category#cache! have been removed. Use Indexes.index (combines index! and cache!), or Indexes[books].index, or Indexes[books][title].index.
  • hanke: (server) Get Indexes/Categories using the #[] method. E.g. Indexes[:books] to get the :books index, and Indexes[:books][:author] to get the :author category of the :books index.
  • hanke: (server) Indexes, Indexes[:some_index], and Indexes[:some_index][:some_category] now all support
the following methods:
  • #index (just index: prepare data and cache data)
  • #reload (just reload the cached data into the server, no effect on Redis indexes)
  • #reindex (index and reload one category after another)
Note: #reload and #reindex only make sense in a running server with memory indexes. Examples:
  • Indexes.index (index all indexes, randomly)
  • Indexes[:some_index].reindex (reindex that index)
  • Indexes[:some_index][:some_category].reload (just reload that category)

Version 2.5.2

  • hanke: (server) Fixed: Redis indexing. Old values are now removed on reindexing.

Version 2.5.1

  • hanke: (server) Minor changes.

Version 2.5.0

  • hanke: (server) Searches can now search in multiple qualifiers, separating them by a “,”. E.g. name,street:tyne.
  • hanke: (server) Searches will no longer search in all categories (fields) if a qualifier has been mistyped. So, namme:peter will not search in all categories, but instead return an empty result if category namme does not exist.

Version 2.4.3

  • hanke: (server) Fixed: Indexing a single category where a #each source was used using rake index:specific[index,category] raised an error.

Version 2.4.2

  • hanke: (server) Live interface for picky-live gem fixed.

Version 2.4.1

  • hanke: (server) Fixes Redis indexing.
  • hanke: (client) Requires activesupport (thanks stanley!).

Version 2.4.0

  • hanke: (server) Added a configuration option key_format for index, categories. It sets the format that this index’/category’s keys are in. Use as you would with source, as either method in the index block, as index parameter, or category parameter.
  • hanke: (client) The client is now finally really data driven by the server, see next changes.
  • hanke: (client) Added two options for the PickyClient, fullResults and liveResults. It designates how many results should be rendered. Defaults are for full: 20, and for live: 0.
  • hanke: (client) The Convenience#ids method now by default returns all ids returned from the server.
  • hanke: (client) The Convenience#populate_with’s second param is not the amount of populated ids anymore. Instead it populates all returned ids by default. If you want less, pass in the up_to option. So, e.g. results.populate_with :up_to => 20.

Version 2.3.0

  • hanke: (server) Integration specs in the server are now easy. In your specs, require 'picky-client/spec'. Example: it {'alan').ids.should == [259, 307, 449] }.
  • hanke: (generators) Added integration specs that use the above tests & matchers to the generated example app.
  • hanke: (client) Added Picky::TestClient which can be used in the server for integration specs. Use, :path => '/your_search_url'), then'bla', :ids => 12, :offset => 0).ids.should ==== [1,3,4] or'blu bli').should have_categories(['title', 'author'], ['title', 'title']) to test category result combinations and order.

Version 2.2.1

  • hanke: (server) Very simple geo search that works best in temperate areas. If you’re just looking for results that are close to yours, give it a go. Use #geo_categories(lat, lng, radius_in_kilometers, options = {})

Version 2.2.0

  • hanke: (server) (BREAKING CHANGE) Since I prefer the block style configuration for indexes, the source is now an optional parameter. Picky will tell you if you still use the old style. New is that you can define the source of an index in the block, e.g.: do source end
  • hanke: (server) Sources can now be anything that responds to #each and that returns objects that respond to #id. (That means you can just pass in an array, or MongoMapper or ActiveRecord’s Book.order('updated_at DESC') or similar)
  • hanke: (server) The app/application.rb API has gotten a few aliases: default_indexing and default_querying can now be called with indexing or searching.
  • hanke: (server) Each index can now have its own indexing. Use e.g. do indexing removes_characters: /[^a-z]/i end.
  • hanke: (server) Each Search can now have its own “searching”, e.g.: do searching removes_characters: /[^a-z]/i end
  • hanke: (server) Added option for collaborators (on the Picky server) of setting the performance ratio if the performance specs fail too often. Just add a spec/performance_ratio.rb file with the content module Picky; PerformanceRatio = x.xx end. Less than 1.0 is more benign, more than 1.0 is harsher.

Version 2.1.2

  • hanke: (server) Improved rake search <url> [<result id amount>] with better description and error handling.

Version 2.1.1

  • hanke: (server) rake search <url>, a simple experimental terminal search interface.

Version 2.1.0

  • hanke: (server) Tokenizing completely rewritten. It works now almost the same in indexing and in querying, with the exception of downcasing (or not, for case sensitive searches).
  • hanke: (server) Indexing and querying now don’t downcase anymore right at the beginning of processing, but rather after text preprocessing. For you this means that you need to use case insensitive regexps /…/i in the config if you need a case sensitive search (get it?).
  • hanke: (server) default_indexing and default_querying offer a new option, case_sensitive, which is by default false. Set it in indexing and querying to true to have your search be case sensitive (usually it is a good idea to set them both to the same case sensitivity). Watch the regexp options – possibly best if you set them to case insensitive /…/i.

Version 2.0.0

  • hanke: Let’s go live, wohoo! :) See the prerelease history notes for all changes.

Version 2.0.0.pre3

  • hanke: (server) Renamed Similarity::DoubleLevenshtone (aka Similarity::Phonetic) to Similarity::DoubleMetaphone (BREAKING: Cannot use Similarity::Phonetic anymore).
  • hanke: (server) Added Similarity::Soundex.
  • hanke: (server) Added Similarity::Metaphone.

Version 2.0.0.pre2

  • hanke: (client) Asterisks are correctly escaped before saved in the browser history.
  • you: Give feedback, thanks! :)

Version 2.0.0.pre1

  • hanke: New major version number – see reasons for API change:
  • hanke: (server) (Breaking change) Query::Full and Query::Live have been replaced by just Search. So what you now do is route /something/ =>, index2, ..., options).
  • hanke: (server) Pass in the ids param to define the amount of result ids you’d like. This is how you’d do it with curl: curl 'localhost:8080/books?query=test&ids=20'. 20 ids is the default.
  • hanke: (client) (Breaking change) Picky::Client::Full and Picky::Client::Live have been replaced by Picky::Client. New option: ids. Pass in to define the amount of ids you’d like. For a live query you need none, so pass in 0. (20 is the default in the server)
  • hanke: (generated clients) See client changes above. Replace Picky::Client::Full and Picky::Client::Live with just a single Picky::Client instance with the same options as before (but just a single URL on the server as desribed above).
  • hanke: (generated servers) See server changes above. Replace Query::Full and Query::Live instance pairs by just a single Search instance.
  • hanke: (client) Added rake javascripts, rake update to the client and client project generator which copies the javascripts from the client gem into your directory. (If you have an old generated project, add require 'picky-client/tasks'; in your Rakefile)

Version 1.5.4

  • hanke: (client) Not breaking the web anymore ;) Using history.js instead of address.js to do away with the hash bang.

Version 1.5.3

  • hanke: (server) rake stats and rake analyze. Get information about your app.

Version 1.5.2

  • hanke: (server) When indexing from the database, the intermediary snapshot table is now called "picky_#{index.identifier}_index" instead of "#{index.identifier}_type_index" to be clearer that it is Picky creating these tables, and what it is. You can remove the …_type_index tables.
  • hanke: (server) The database source now uses mostly AR adapter methods to make it more agnostic.

Version 1.5.1

  • hanke: (server) Picky now traverses more cleanly over your database data. (Thanks Jason Botwick!)

Version 1.5.0

  • hanke: (server) Redis backend.
  • hanke: (server) The Redis backend uses db 15.
  • hanke: (server) The mysql gem is used by default.

Version 1.4.3

  • hanke: (server) Fix for non-working picky command line interface. (Thanks Jason Botwick!)

Version 1.4.2 (Redis backend prerelease)

  • hanke: (server) Redis backend prototype.
  • hanke: (server) rake index:specific[index] or rake index:specific[index,category] to index just a specific index or category.
  • hanke: (server) Postgres source better handled.

Version 1.4.1

  • hanke: (client/generators) The choices option is now localized. If you have generated a new Picky project with 1.4.0, please do localize your choices like so: choices:{ (formats here) } => choices:{en:{ (formats here) }} and whatever locales you’d like to use.

Version 1.4.0

  • hanke: (client/generators) Latest Javascript PickyClient object includes the option to format the choices better, option group: [['author', 'title', 'subjects'], ['publisher']] lets you group certain categories together while option choices: { 'title': format: "<strong>%1$s</strong>", filter: function(text) { return text.toUpperCase(); }, ignoreSingle: false } lets you define how each combination is handled in detail. Again, hard to explain, easy to see. (see issue for details, closes issue 9)
  • hanke: (client/generators) Added a wrapResults options where you can define wrapper HTML bits that are wrapped around each allocation group of <li> results. The default is: wrapResults: '<ol class="results"></ol>'.
  • hanke: (client/generators) Headers are now contracted, this means no more “written by florian and written by hanke”, but “written by florian hanke”. (closes issue 10)
  • hanke: (client) Split #interface method into => #input, #results, so that users can wrap each with custom elements. Don’t forget to wrap into a div#picky.
  • hanke: (generators, breaking change!) Example now constricts the Picky interface width using a div.content. Please use a wrapper div to constrict div#picky.
  • hanke: (generators) Cleanup of Javascript code, inclusion of formerly external javascripts (scrollTo, timer, jQuery 1.5).
  • hanke: (generators, possible breaking change!) Interface HTML structure refactor. Results should now be li-s. Result groups (combinations/allocations, around the result li-s) are each inside an ol.results. Please check your CSS files if they need to be adapted to the new structure.
  • hanke: (generators) Cleanup of CSS, much more flexible and specific.

Version 1.3.4

  • hanke: (generators/client) In the generated Sinatra client, queries can be passed in through the query param q. Example:
  • hanke: (generators/client) In the generated sinatra client, the back/forward buttons work via jquery.address plugin. Closes github issue 6.

Version 1.3.3

  • hanke: (server/client) Server now sends the similar word instead of the original in similarity tokens (semelor~ → similar). Even if that means, that the original way of writing is not preserved (SEmElOr~ → similar). We’re trying to help people have good searches, so there.

Version 1.3.2

  • hanke: (all) Fixed description in the “picky” command. Also now shows optional parameters more clearly.

Version 1.3.1

  • hanke: (server) Ability to handle string/symbol keys (for future key/value store data sources).
  • hanke: (server) Live interface uses select instead of sleep in the master process.

Version 1.3.0

  • hanke: (server) Offers a new routing API, an interface that permits changing parameters in the running server. Use route %r{/admin} =>
  • hanke: (statistics) The statistics server is now called “Clam”, a chain smoking friend of Picky’s.
  • hanke: (live) A new Gem “picky-live” that offers a live interface into the Picky server, provided you have a route for it. It is called “Suckerfish”, and is one of Picky’s friends, too.

Version 1.2.4

  • hanke: (server) default_indexing (in the application.rb) provides a new option reject_token_if => some_lambda, e.g.: reject_token_if: lambda { |token| token.nil? || token == :hello } where you can define which tokens go into the index, and which do not. Default lambda is: &:empty?. This means that only non-empty tokens are saved in the index. You could, for example, not save tokens that have length < 2 (since they might be too small for your purposes). Note that tokens are passed into the hash as symbols.
  • hanke: (statistics) Fixed a bug where the last line in the log file was counted once a second time after reloading the stats.
  • hanke: (statistics) Slight interface redesign.

Version 1.2.3

  • hanke: (server) Fixed a bug where the partial strategy Partial::None was not correctly used: A query like Peter did not return results even if “Peter” could be found using quotes: “Peter” (FYI, double quotes force Picky to use the exact index instead of the partial one. While, conversely, the asterisk* forces Picky to use the partial index instead of the exact one).

Version 1.2.2

  • hanke: (statistics) Statistics server handles logfile reading in a cleaner way when the gem has been installed by root.

Version 1.2.1

  • hanke: (statistics) (BETA) New statistics gem for Picky. Run picky stats path/to/your/search.log [port] to start a statistics server. Go to http://localhost:4567 after running the command to take a look.

Version 1.2.0

  • hanke: (client) (BREAKING) => ‘bla’) has changed to‘bla’), as the query itself is not optional. The rest of the options is still passed in as a Hash through the second parameter.

Version 1.1.7 (1.2.0 pre)

  • hanke: (server) Redefined API for 1.1.6 beta feature, ranged search.
  • hanke: (documentation) API for #define_ranged_category.

Version 1.1.6

  • hanke: (server) Enabled beta feature “low/high limited range search”, see API RDoc (IndexAPI class).

Version 1.1.5

  • hanke: (server) Passing in a similarity search (e.g. with text “hello”) will never return “hello” as a similar token.

Version 1.1.4

  • hanke: (generators) Removed unnecessary jquery-1.3.2 from client, since it wasn’t referenced anyway.

Version 1.1.3

  • hanke: (server) The CouchDB source now uses a little trick/hack to make its ids work in Picky. They are translated into decimal numbers from its hex string representations. Recalculate using #to_s(16) before getting objects from CouchDB in a webapp.

Version 1.1.2

  • hanke: (generators) Added generator for empty unicorn projects, use picky generate empty_unicorn_project <project_name> to generate one.

Version 1.1.1

  • hanke: (server and client) Removed generator projects that have been moved to picky-generators. Gems now much smaller :)

Version 1.1.0

  • hanke: (server and client) Generators extracted into picky-generators gem.
  • hanke: (generators) Generators and example projects for both server and client.

Version 1.0.0

  • hanke: Lots of API RDoc.
  • hanke: Yaaaay! Finally :)

Version 0.12.3 (1.0.0 pre4)

  • hanke: (server) Fixed cased file name (led to problems under Linux, thanks Bernd Schoeller)

Version 0.12.2 (1.0.0 pre3)

  • hanke: (server) New :from option. Assume you have a source, file:'some_file.csv') but you want the category to be called differently. Use the from option as follows: define_category(:similar_title, :from => :title).
  • hanke: (server) CSV source uses FasterCSV, passing through all its options (col_sep, row_sep et cetera).
  • hanke: (server) More understandable output for rake try, rake try:index, rake try:query.

Version 0.12.1 (1.0.0 pre2)

  • hanke: (server) Fixed a bug where the default qualifier definition (like the author in the query author:tolkien) for categories were ignored.

Version 0.12.0 (1.0.0 pre1)

  • hanke: (server) API change in application.rb: Use #define_category instead of #category on an index. (category still possible, but deprecated)
  • hanke: (server) Internal rewrite.

Version 0.11.2

  • hanke: (server) Rake task index:check will check if all necessary index files are generated. (Nice to use before restarting.)

Version 0.11.1

  • hanke: (server) Better error reporting in Rake tasks. Task naming improved.
  • hanke: (server) Internal cleanup.

Version 0.11.0

  • hanke: (server) Major API and internals rewrite. See generated project for help.

Version 0.10.5

  • hanke: (server) Source CouchDB added (thanks to

Version 0.10.4

  • hanke: (server) Typo fixed (thanks to

Version 0.10.3

  • hanke: (client) Helpful configuration page in the client at /configure.

Version 0.10.2

  • hanke: (server) Phonetic similarity (e.g. lyterature~) available through, see example.

Version 0.10.1

  • hanke: (server) :weights option for queries also ok in the form: { [:cat1, :cat2] => 4 }, where 4 is any weight.

Version 0.10.0

  • hanke: (server) (BREAKING) Total rewrite/exploration of the Application API.
    Stay on 0.9.4 if you don’t want to update right now.
  • hanke: (server) Character substitution now configurable. Default is no character substitution.

Version 0.9.4

  • hanke: (server) rake routes: Shows all current URL paths, and if they are processable fast.

Version 0.9.3

  • hanke: (server) Fixed: Querying parameters are not ignored anymore.

Version 0.9.2

  • hanke: (client) Fixed result_hash.entries to return the right amount of entries.
  • hanke: (client) The result_hash#entries now takes a block and replaces the e.g. AR instances with e.g rendered results.
  • hanke: (client) Locale handling fixed. Uses the locale of the HTML tag by default.

Version 0.9.1

  • hanke: (server) Delicious missing gem notice if www-delicious gem is missing.
  • hanke: (server)Partial::Subtoken renamed to Partial::Substring.
    Options: down_to → from, starting_at → to
  • hanke: (server) Index bundle file handling extracted into specific Index::Files backend.

Version 0.9.0

  • hanke: (server/client) Jump to 0.9.0 to work on API, release 1.0.0 soon.
  • hanke: (server) Partial indexing now only down to -3, e.g. florian → partial: floria, flori, flor.
    If you want down_to the first character (florian, floria, flori, flor, flo, fl, f), use:
    field(:some_field_name, :partial => => 1))
  • hanke: (server), pass) for indexing your delicious posts.
  • hanke: (server) indexing and querying config now done on tokenizer instances.

Version 0.3.1

  • hanke: (server) Generator gives more informative NoGeneratorError message.

Version 0.3.0

  • hanke: (server) Uses json (index, index weights) and marshal (similarity index) to dump indexes.
  • hanke: (server) Generator is more helpful (thanks to
  • hanke: (server) Generator for a Sinatra project. (picky-client sinatra project_name <- Note: Changed to picky generate sinatra_client project_name)
  • hanke: (client) Helpful generator. (thanks to

Version 0.2.4

  • hanke: (server) Indexing output, output in general cleaned up.
  • hanke: (server) Better info after generating a new project (thanks kschiess).
  • hanke: (server) Indexer now uses json for the dump files (much faster, slightly larger, thanks to
  • hanke: (client) JS files rewritten.

Version 0.2.3

  • hanke: (server) Explicit index buffering: Indexer hits filesystem only seldomly.
  • hanke: (server) Internal rename from full index to exact index (visible in index filenames).
  • hanke: (server) Solr Indexing removed until someone needs it. Then we’ll talk cash. Just kidding.
  • hanke: (server) Improved Gemfile.

Version 0.2.2

  • hanke: (server) Umlaut handling (i.e. character substitution) now pluggable.
  • hanke: (server) Apps finalization now handled through Ruby callback (thanks to

Version 0.2.1

  • hanke: (server) Fix for negative partial index values (:partial => => -3))

Version 0.2.0

  • hanke: (server) Only uses JSON to encode results.
  • hanke: (client) Only uses JSON for full and partial queries.

Version 0.1.0

  • hanke: (server) Application interface rewrite. See a freshly created
    project (using picky project <- Note: Renamed picky generate unicorn_server ).

Version 0.0.9

  • hanke: (client) Cleanup. Frontend example.

Version 0.0.8

  • hanke: (server) Application#add_index instead of Application#type.
  • hanke: (server) Simplified scaffolding.

Version 0.0.7

  • hanke: (server) Gem compiles on install. Do not compile on run.

Version 0.0.6

  • hanke: (server) Removed unnecessary gem dependencies (thanks to niko).
  • hanke: (server) Added CSV to the possible Sources., :author, :isbn, :file => ‘data/books.csv’),
  • hanke: (server) Renamed all instances of SEARCH_* constants to PICKY_*. (Uses RACK_ENV)

Version 0.0.5

  • hanke: (server), now top level in newly created project (more standard).
  • hanke: (server) Port now defined in (use listen ‘host:port’).
  • hanke: (client) Enriched callbacks in the JS interface definition (before, success, after).

Version 0.0.4

  • hanke: (client) Interface now created using Picky::Helper.interface or .cached_interface (if you only have a single language in your app).

Version 0.0.3

  • hanke: (server) C-Code cleaned up, removed warnings.

Version 0.0.2

  • hanke: (server) Newly created application better documented.

Version 0.0.1

  • hanke: (server/client) Initial project. Server (picky) and basic frontend client (picky-client) available.
Something went wrong with that request. Please try again.