README.rdoc Samples/Amazonifty/amazon.xml Samples/Amazonifty/viewer/d1d8ab47557f0f5a/info.css Samples/Amazonifty/viewer/d1d8ab47557f0f5a/info.js Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/1d03ca03e76d140e_big.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/1d03ca03e76d140e_small.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/71aa43efd0fdd671_big.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/71aa43efd0fdd671_small.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/fdae913172896bce_big.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/fdae913172896bce_small.png @@ -1,24 +1,12 @@ == Client Side -+ form submission & ajax saving -+ "dirty" instances -+ beforeLeaving event for pages -+ 'entity is dirty' warning for saving changes -+ fields with left labels -* fieldsets -+ side panel fields -* all sorts of rendering issues -+ entity-panel knows all the fields & fieldlets -+ no save if not valid. * Smart-tabing between instances * blur & focus events for instances + color dirty instances + update displayItem with values, via handlers. -* field can be single or multiple ++ field can be single or multiple * show new empty instance on multiple edit fields -* focus on the first editItem when editing instance -* report for changes on the page -+ ability to save changes - graphicaly ++ focus on the first editItem when editing instance + template-based markup generating for field, field-instnace & fieldlet, for using with grid (list) @@ -72,51 +60,3 @@ * many stories * find a way to test fieldlets (maybe "interface-like" tests? (respond_to? :required_method)) - -=== Fieldlets architecture - -+ no instantce_id anymore => round robin loading for filling instances -* to delete instance => send every fieldlet in it to be NULL valued -* fieldlets are not deleted, their values are set to null instead -* instance is deleted only if all it's fieldlets values are null -+ dual side links duplicates the instance also - - -Entity Cycle: - -+ load: - - fetch all the fieldlets by the entity_id(s) - - iterate over fieldlets - - call load_callback - - push to the FieldFactory and add/create instances - - push to the entities_to_fieldlets<entity_id => [<fieldlet,...>]> - - - fetch all entities required - - for each fieldlet in entities_to_fieldlets, call callback - - initiate with fields loaded - - - serve by fieldlet/field - - - -==== JS things: - -+ Make sure all the base classes are preconfigured -* clean up some messy code -* make the JIT tabs work, etc -* clean up events -+ refactor entity fields, instances & fieldlets - -* adding new field instance - -********************** - -* empty fieldlets in partialy filed fields should not be new but empty instead -+ fix the 'latest' in schema -+ move to 64 bit identifiers -* load fieldlets with position priority - - - - - TODO @@ -7,6 +7,15 @@ module App # attr_accessor :fields, :fieldlets, :instances + + ## + # Setup the fields-fieldlets structure, iterates over the given fieldlets + # and push them to their corrsponding fields + # + # @param [Array[App::Fieldlet]] fieldlets. an array of loaded fieldlets + # + # @see Entity.find_with_fieldlets + # def init_fieldlets(fieldlets=[]) fieldlets.each do |fieldlet| push_fieldlet_to_field(fieldlet) @@ -16,7 +25,24 @@ module App end end - # push fieldlet to a running instance + ## + # Push the given fieldlet to its field class + # + # @param [App::Fieldlet] the fieldlet to push + # + # === Notes + # * The last instance of the fieldlet's field class is chosen + # + # * If there are no instances for the field class, or the + # instance_id of the fieldlet is different from the fieldlet's instance_id + # a new field instance will be created. + # + # * The fieldlet is pushed into the instance (@see Field#push) + # + # * We assume that all the fieldlets are order by the instance_id, + # so when the instance_id changes, we KNOW that we should move + # to another instance + # def push_fieldlet_to_field(fieldlet) field = @fields[fieldlet.class::FIELD_ID].last @@ -30,13 +56,27 @@ module App @fields[fieldlet.class::FIELD_ID] << field # set up instances - @instances[fieldlet[:instance_id]] = field end - ## class methods - + ## == ClassMethods + + + ## + # Fetch entities by the given ids, and load their fieldlets. + # + # @param [String] *args - one or more hex encoded entity ids + # + # @return [nil] if no entity found + # @return [App::Entity] if single entity found + # @return Array[App::Entity] array of entities if more than one found + # + # === Notes + # * First we load the fieldlets for all the given entity ids + # * We load all the entities by the given ids and the linked entities + # * We return only the requested entities + # def self.find_with_fieldlets(*args) entities_to_load = {} @@ -70,7 +110,18 @@ module App return prepere_fetch_result(ids, entities) end - + ## + # Load the entities with the ids from the entities_to_load hash keys + # for each loaded entity, call the proc given as the hash value + # and yield the entity + # + # @param [Hash{String => Array[Proc]}] entities_to_load + # + # @yield proc to run on each entity after running the callbacks + # @yieldparam [App::Entity] + # + # @return [App::Entity] the loaded entities + # def self.fetch_entities_with_callbacks(entities_to_load) return [] if entities_to_load.empty? @@ -94,6 +145,15 @@ module App protected + ## + # Convert the given args from hex to fixnum and push them into the given + # entities_to_load hash + # + # @param [Array[String]] list of entity ids (hex encoded) + # @param [Hash{Fixnum => Array[Proc]}] hash to push converted ids to + # + # @return [Array[Fixnum]] the converted ids + # def self.convert_ids_and_push_to_entities_to_load!(args,entities_to_load) ids = args.collect{|x| x.to_i(16)} @@ -101,6 +161,19 @@ module App ids.each{|id| entities_to_load.merge!(id => [])} end + + ## + # Return only the entities that their id is in ids + # (@see Entity.find_with_fieldlets) + # + # @param [Array[Fixnum]] ids list of entity ids + # @param [Array[App::Entity]] entities - a list of entities to filter on + # + # @return [nil] if no entity found + # @return [App::Entity] if single entity found + # @return Array[App::Entity] array of entities if more than one found + # + def self.prepere_fetch_result(ids, entities) # return only requested entities entities.reject!{|e| !ids.include? e[:id]} app/models/app/entity/fetching.rb @@ -1,24 +1,19 @@ module App class Entity < Sequel::Model - # Writing related methods - # - # - # Updates the fieldlets and add new fieldlets to the fiedls - # - # ==== Parameters - # instances_hash<Hash>:: a hash which will used to update the fieldlet hash + ## + # Adds, updates and removes field instances for the entity # - # ==== Example + # @param [Hash] instance_hash # - # set_fieldlets({5691 => {10 => 'value'}, 'new' => [-1 => {10 => 'value', 11 => 'blalbla'}, -2 => {10 => 'value'}]}) + # === instance_hash examples + # * Updating: {<InstanceID> => {<FieldletKind> => <FieldletValue>}} + # {'80044300905744541' => {'4589dcc19104b5ad' => 'Merb'}} + # {'80044300905278446' => {'2a1f35b7547e73a7' => {x: 12, y: 34}}} # - # + # * Adding: {'new' => {<UniqInstanceID> => {<FieldletKind> => <FieldletValue>}}} + # * Removing: {'remove' => {<InstanceID> => true}} # - - # set_fieldlets({'new' => {1 => {'9ae9d4f04db7012bad310014512145e8' => 'nifty'}}}) - # Field instance id =^ Fieldlet guid =^ Fieldlet value =^ - def instances=(instances_hash) @fieldlets_by_type ||= {} #for later lambda reference of the new fieldlets @entities_to_load = {} @@ -32,7 +27,19 @@ module App return true end - # create new instances from the given hash + + ## + # Adds field instances for the entity + # + # @param [Hash] instance_hash + # + # === instance_hash examples + # {<UniqInstanceID> => {<FieldletKind> => <FieldletValue>}} + # {'80044300905744541' => {'4589dcc19104b5ad' => 'Merb'}} + # + # + # The UniqInstanceID has no real usage, it is only used the group fieldlets + # from the same instance def add_instances!(instances_hash) return if !instances_hash instances_hash.each do |uniq_id, fieldlets_hash| @@ -60,6 +67,15 @@ module App # instances_hash = {<instance_id> => <field_id>} # + ## + # Removes field instances for the entity + # + # @param [Hash] instance_hash + # + # === instance_hash examples + # {<InstanceID> => true} + # {'80044300905744541' => true} + # def remove_instances!(instances_hash) return if !instances_hash instances_hash.each do |instance, value| @@ -67,7 +83,16 @@ module App end end - # instance_hash = {<instance_id> => {<fieldlet_kind> => <value>, ...}} + ## + # Updates field instances for the entity + # + # @param [Hash] instance_hash + # + # === instance_hash examples + # {<InstanceID> => {<FieldletKind> => <FieldletValue>}} + # {'80044300905744541' => {'4589dcc19104b5ad' => 'Merb'}} + # {'80044300905278446' => {'2a1f35b7547e73a7' => {x: 12, y: 34}}} + # def update_instances!(instances_hash) return if !instances_hash @@ -96,52 +121,56 @@ module App end end - + + ## + # Saves the entity and the fieldlets + # sets the display value of the entity based on the fieldlets + # + # @return [Boolean] true if the entity saved correctly, false if the + # validation Failed # - # a place for improvement + # ==== Notes + # * If no fieldets, saves only the entity + # * If the fieldlets do not validate, don't save and return false + # * Saves entity and fieldlets in a transaction + # + def save_changes + set_display_value() + return super if !@fields # if no fieldlets, save the normal way + return false if !self.fields.values.all?{|field| field.all?{|instance| instance.valid?}} + + self.db.transaction do + if(@new) + self.save + else + super #call for the inherited save action - saves the entity + end + + @fields.values.each{|field| field.each{|instance| instance.save}} + end + return true + end + + ## + # Sets the 'display' column on the entity row to the evaluated proc + # stored in the DISPLAY_LAMBDA const of the class # - - # Saves the entity and the fieldlets - # - # ==== Returns - # <Boolean>:: true if save was successful, false if validation failed - # - # ==== Notes - # * If no fieldets, saves only the entity - # * If the fieldlets do not validate, don't save and return false - # * Saves entity and fieldlets in a transaction - # - def save_changes - set_display_value() - return super if !@fields # if no fieldlets, save the normal way - return false if !self.fields.values.all?{|field| field.all?{|instance| instance.valid?}} - - self.db.transaction do - if(@new) - self.save - else - super #call for the inherited save action - saves the entity - end - - @fields.values.each{|field| field.each{|instance| instance.save}} - end - return true - end - - # sets the display value according to the given lambda - - def set_display_value - if self.class::DISPLAY_LAMBDA - self.display = self.class::DISPLAY_LAMBDA.call(@fieldlets_by_type) - end - end - - - def generate_entity_pk - s = "" - 8.times{s << rand(256).to_s(16)} - @values[:id] = s.to_i(16) # 64 bits random - end - + def set_display_value + if self.class::DISPLAY_LAMBDA + self.display = self.class::DISPLAY_LAMBDA.call(@fieldlets_by_type) + end + end + + ## + # Generates a random 64bit integer for usage as a primary key for entities + # + # @return [Fixnum] 64bit random + # + def generate_entity_pk + s = "" + 8.times{s << rand(256).to_s(16)} + @values[:id] = s.to_i(16) # 64 bits random + end + end end \ No newline at end of file app/models/app/entity/writing.rb @@ -1,23 +1,43 @@ Dir.glob(Merb.root / 'app'/ 'models' / 'app' / 'field' / '*.rb').each{|f| require f} -# = Field -# The field class -# -# -# -# + module App + ## + # = Field + # Encapsulate field instance and link duplication behavior. + # Responsible for creating, updating and deleting instances and their linked instances + # + # === Usage class Field include Enumerable include Namespacing + ## + # Constructor + # + # @param [App::Entity] entity that the field belongs to + # @return [App::Field] + # + # === Notes + # * duplicant is for the other side of an optional link. @see Field#duplicant def initialize(entity) @entity = entity @fieldlets = {} @duplicant = nil end - # push fieldlets + ## + # Push a given fieldlet to this field instance + # + # @param [App::Fieldlet] fieldlet to be pushed + # @return [App::Fieldlet] the given fieldlet + # + # @raise [Exception] if the given fieldlet's field class don't match this + # instance's class + # + # === Notes + # * If the fieldlet have instance_id, it is set for the field instance's instance_id + # def push(fieldlet) if (self.class != fieldlet.class::FIELD) raise "FieldletKind mismatch: expected #{self.class} but got #{fieldlet.class::FIELD}" @@ -30,23 +50,50 @@ module App alias :<< :push - # for usage with Enumerable mixin + ## + # Each implementation required by the Enumerable mixin + # + # @yield a block for iterating on the filedlets in this instance + # @yieldparam [App::Fieldlet] the currently iterated fieldlet + # def each(&block) @fieldlets.values.each(&block) end - + + ## + # Returns or sets the 64bit instance_id "random" + # + # @return [Fixnum] 64bit instnace_id random + # + # === Notes + # * The left side of the number is the current time, the right side is a random number + # def instance_id @instance_id ||= ((Time.now.to_f * 1000).to_i << 16) + rand(1024 * 64) end + ## + # Checks if this instance is empty or all its fieldlets are new + # + # @return [Boolean] true if there are no fieldlets or that non of the fieldlets is new + # def new? @fieldlets.empty? || self.all?{|x| x.new?} end + ## + # Checks if all of the fieldlets have value + # + # @return [Boolean] true if all the fieldlets have no value, false otherwise def null? !self.all?{|x| x.value?} end + ## + # Checks this instance is new and all the fieldlets have no value + # + # @return [Boolean] true if all the fieldlets have no value and this instance + # is new. otherwise instead def clean? self.new? && self.null? end app/models/app/field.rb @@ -11,165 +11,45 @@ # # Add the app's "gems" directory to the gem load path. -# Note that the gems directory must mirror the structure RubyGems uses for -# directories under which gems are kept. -# -# To conveniently set it up, use gem install -i <merb_app_root/gems> -# when installing gems. This will set up the structure under /gems -# automagically. -# -# An example: -# -# You want to bundle ActiveRecord and ActiveSupport with your Merb -# application to be deployment environment independent. To do so, -# install gems into merb_app_root/gems directory like this: -# -# gem install -i merb_app_root/gems activesupport-post-2.0.2.gem activerecord-post-2.0.2.gem -# -# Since RubyGems will search merb_app_root/gems for dependencies, order -# in the statement above is important: we need to install ActiveSupport which -# ActiveRecord depends on first. -# -# Remember that bundling of dependencies as gems with your application -# makes it independent of the environment it runs in and is a very -# good, encouraged practice to follow. Gem.clear_paths Gem.path.unshift(Merb.root / "gems") -# If you want modules and classes from libraries organized like -# merbapp/lib/magicwand/lib/magicwand.rb to autoload, -# uncomment this. +# Lib path Merb.push_path(:lib, Merb.root / "lib") # uses **/*.rb as path glob. # ==== Dependencies -# These are some examples of how you might specify dependencies. -# Dependency loading is delayed to a later Merb app -# boot stage, but it may be important when -# another part of your configuration relies on libraries specified -# here. -# -# dependencies "RedCloth", "merb_helpers" -# OR -# dependency "RedCloth", "> 3.0" -# OR -# dependencies "RedCloth" => "> 3.0", "ruby-aes-cext" => "= 1.0" - dependency 'merb-assets' dependency 'nifty-q' Merb::BootLoader.after_app_loads do require 'lib/nifty_base_fieldlets/lib/nifty_base_fieldlets' - # Add dependencies here that must load after the application loads: - ### Add dependencies here that must load after the application loads: - - + # load schema VM::Schema.load! if Merb.config[:auto_load_schema] - - - # dependency "magic_admin" # this gem uses the app's model classes end -# -# ==== Set up your ORM of choice -# - -# Merb doesn't come with database support by default. You need -# an ORM plugin. Install one, and uncomment one of the following lines, -# if you need a database. - -# Uncomment for DataMapper ORM -# use_orm :datamapper +# ==== Libraries -# Uncomment for ActiveRecord ORM -# use_orm :activerecord - -# Uncomment for Sequel ORM +# ORM use_orm :sequel - -# -# ==== Pick what you test with -# - -# This defines which test framework the generators will use. -# RSpec is turned on by default. -# -# To use Test::Unit, you need to install the merb_test_unit gem. -# To use RSpec, you don't have to install any additional gems, since -# merb-core provides support for RSpec. -# -# use_test :test_unit +# TESTING use_test :rspec # # ==== Set up your basic configuration # -# IMPORTANT: -# -# early on Merb boot init file is not yet loaded. -# Thus setting PORT, PID FILE and ADAPTER using init file does not -# make sense and only can lead to confusion because default settings -# will be used instead. -# -# Please use command line options for them. -# See http://wiki.merbivore.com/pages/merb-core-boot-process -# if you want to know more. Merb::Config.use do |c| # Sets up a custom session id key which is used for the session persistence # cookie name. If not specified, defaults to '_session_id'. c[:session_id_key] = '_nifty_session_id' - # The session_secret_key is only required for the cookie session store. - c[:session_secret_key] = '52c50ce5607af46f1936e184876da78f10eadf3b' # There are various options here, by default Merb comes with 'cookie', # 'memory' or 'memcached'. You can of course use your favorite ORM # instead: 'datamapper', 'sequel' or 'activerecord'. - c[:session_store] = 'cookie' + c[:session_store] = 'memory' end - - -# ==== Tune your inflector - -# To fine tune your inflector use the word, singular_word and plural_word -# methods of Language::English::Inflector module metaclass. -# -# Here we define erratum/errata exception case: -# -# Language::English::Inflector.word "erratum", "errata" -# -# In case singular and plural forms are the same omit -# second argument on call: -# -# Language::English::Inflector.word 'information' -# -# You can also define general, singularization and pluralization -# rules: -# -# Once the following rule is defined: -# Language::English::Inflector.rule 'y', 'ies' -# -# You can see the following results: -# irb> "fly".plural -# => flies -# irb> "cry".plural -# => cries -# -# Example for singularization rule: -# -# Language::English::Inflector.singular_rule 'o', 'oes' -# -# Works like this: -# irb> "heroes".singular -# => hero -# -# Example of pluralization rule: -# Language::English::Inflector.singular_rule 'fe', 'ves' -# -# And the result is: -# irb> "wife".plural -# => wives config/init.rb README app/models/app/entity/entity_data_manipulation.rb 74ca418747e6412995b8d506860aa3fa1a4a4849 Shlomi Atar shlomiatar@Macintosh.local http://github.com/shlomiatar/nifty-vm/commit/a6fd55211cd08f3e3ab1e9c704dc4bbb23f6e5f0 a6fd55211cd08f3e3ab1e9c704dc4bbb23f6e5f0 2008-09-29T07:23:31-07:00 2008-09-29T07:23:31-07:00 moved samples to the samples dir, add git ignore file 5c81abe4da4d3e4468ca4ca5b6ee4a9090a4d922 Shlomi Atar shlomiatar@Macintosh.local