whowish_word 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+
+/Gemfile.lock
+spec/rails/tmp/*
+*.gem
+rails/db/*.sqlite3
+rails/tmp/*

data/.loadpath

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<loadpath>
+	<pathentry path="" type="src"/>
+	<pathentry path="org.rubypeople.rdt.launching.RUBY_CONTAINER" type="con"/>
+</loadpath>

data/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>whowish_word</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.rubypeople.rdt.core.rubybuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.rubypeople.rdt.core.rubynature</nature>
+	</natures>
+</projectDescription>

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gem 'rspec'

data/HOW_TO_BUILD_WHOWISH_HOOK.md

@@ -0,0 +1,10 @@
+Process to discover where to put the hook
+--------------------------------------------
+
+In a view, please a try-catch block and print all traces.
+
+Do this in:
+1. layout
+2. normal view
+3. partial
+4. nested layout

data/ISSUE.md

@@ -0,0 +1,93 @@
+Current issues
+==================
+
+
+
+Support different database engine 
+-------------------------------------------------
+
+It is painful to use WhowishWord on different database (MySQL, PostgreSQL, MongoDB, Redis, ...).
+
+Here is a cycle for a database
+
+- Initialize structure
+- Save migration version
+- Rails uses it
+- Do another migration
+- Save the new version 
+
+There must be a better way that:
+- lets user configure easily
+- does not depend on 3rd library (No ORM. Really? Should we do that?)
+	- ActiveRecord is ok
+	- Mongoid is not, because it is not a standard
+- 
+
+### Solution
+
+Just Support them directly...
+
+
+### (Not good) Solution
+
+Use SQLite instead.
+However, this poses another problem. SQLite cannot be run on Cloud service, e.g. Heroku.
+
+
+
+
+
+A way to activate edit mode (Solved!)
+-------------------------------------------------
+
+It should be activate-able inside Rails application, e.g. a call to WhowishWord.activate_edit_mode.
+We let user manage its own session.
+
+The thing to look out is that we have to be careful about using a global variable within WhowishWord gem
+because it is shared among users....
+
+### Solution
+
+Create a single point of activating an edit mode, WhowishWord.activate_edit_mode()
+
+
+
+Javascript text issue (Solved!)
+----------------------
+
+Javascript text being enclosed with single-quotes causes an error 
+(Even if we'd change to double-quotes enclosing, there would still be a problem)
+
+
+### Solution 1
+
+User is responsible to make sure that all quotes are escaped.
+
+Input text attributes (Solved!)
+----------------------
+
+In edit mode, we cannot add edit icon next to the element, which owns the attribute.
+
+### Solution
+
+Use javascript to add the edit icon.
+
+1. Generate a unique text in the attribute
+2. Get the element by searching for the unique text
+3. Replace text with a whowish word
+4. Add edit icon to the element
+
+When getting an element, we have to store the element and the attribute's name in a hash for future use.
+This is because the element might not have its own ID.
+
+
+Select box options (Solved!)
+---------------------
+
+In edit mode, we cannot edit whowish word in option's value and option's text
+
+### Solution
+
+Use javascript to generate edit icon
+
+

data/README.md

@@ -0,0 +1,72 @@
+WhowishWord
+====================
+
+Have you ever been bored when a project manager (or marketing department) keeps changing wording on a website?
+
+WhowishWord facilitates the process of changing wording on a website.
+
+
+How you should work
+-------------------
+
+1. Activate edit mode through http://your_domain/whowish_word
+2. Go back to the website, you'll see an edit icon on each word
+3. Click on an edit icon to edit the corresponding word
+4. Fill in a new word, and click save
+
+And when you have finished, deactivate edit mode.
+
+WhowishWord empowers normal users (project manager, marketing department, or sales) to change wording on a website.
+This take the burden off programmers because it is extremely boring to change wording...
+
+
+Prerequisite
+-------------------
+
+Rails 3.0.*
+
+(Haven't tested with Rails 3.1.*)
+
+
+How to use it
+-------------------
+
+First, install it:
+```
+gem install whowish_word
+```
+
+Or, in your Gemfile, put in the below line:
+```
+gem 'whowish_word'
+```
+
+Second, create RAILS_ROOT/config/initializers/whowish_word.rb that contains:
+
+```ruby
+require 'whowish_word'
+
+WhowishWord.ini
+```
+
+You can use either use :mysql or :mongodb
+(I have planned to add :redis and :postgresql)
+
+Performance
+-------------------
+
+It is fast because words are kept in memory. They are not kept in database while your Rails is running.
+
+
+How to extend WhowishWord to suit your need
+-------------------------------------------------
+
+WhowishWord is nicely structure. You can extend it by writing a new handler and creator (on client-side) and a new generator (on server-side).
+
+Please learn the code structure. If you have any question, feel free to ask me.
+
+
+Author
+-------------------
+
+Tanin Na Nakorn

data/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run WatirRails::Application

data/lib/legacy/whowish_word/config.rb

@@ -0,0 +1 @@
+WHOWISH_WORD_DATABASE_ENGINE = "mongodb" # mongodb or mysql

data/lib/legacy/whowish_word/init.rb

@@ -0,0 +1,4 @@
+
+
+require File.dirname(__FILE__)+'/lib/hook'
+require File.dirname(__FILE__)+'/lib/db_migration'

data/lib/legacy/whowish_word/lib/app/controllers/whowish_word_controller.rb

@@ -0,0 +1,115 @@
+class WhowishWordController < ActionController::Base
+  before_filter :compact_policy,:check_whowish_word_admin, :choose_locale
+  before_filter :check_whowish_word_login, :except=>[:login,:do_login]
+  
+  def check_whowish_word_login
+    
+    render :login, :layout=>nil if session[:whowish_word_login] != "true"
+  end
+  
+  def check_whowish_word_admin
+    $whowish_word_admin = session[:whowish_word_admin]
+  end
+  
+  def compact_policy
+    response.headers['P3P'] = 'policyref="/w3c/p3p.xml", CP="'+COMPACT_POLICY+'"'
+  end
+  
+  layout "whowish_word_blank"
+
+  def do_login
+    if params[:password] == "whowish#456"
+      session[:whowish_word_login] = "true"
+      index
+      render :index
+    else
+      @error = "The password is invalid."
+      render :login, :layout=>"blank"
+    end
+  end
+  
+  def logout
+    session[:whowish_word_login] = nil
+    render :login, :layout=>"blank"
+  end
+
+  def activate
+    if params[:enabled]=="yes"
+      session[:whowish_word_admin] = true
+    else
+      session[:whowish_word_admin] = false
+    end
+    
+    render :json=>{:ok=>true}
+  end
+
+
+  SHOW_FIELDS = [
+          {:id=>"word_id",:width=>300},
+          {:id=>"content",:type=>"textarea",:width=>350}]
+
+  def index
+    @fs = SHOW_FIELDS
+  end
+  
+  def get_word
+    logger.debug { "locale=#{$locale}"}
+    entity = WhowishWord.first(:conditions=>{:word_id => params[:word_id].strip})
+    
+    render :json=>{:content=>""} and return if !entity
+    render :json=>{:content=>entity.content}
+  end
+
+  def change_word
+
+    entity = nil
+
+    if params[:id]
+      entity = WhowishWord.first(:conditions=>{:id => params[:id]})
+    else
+      entity = WhowishWord.first(:conditions=>{:word_id => params[:word_id].strip})
+    end
+    
+    if !entity
+      #render :json=>{:ok=>false,:error_message=>"Cannot find "+params[:page_id]+":"+params[:word_id]} and return 
+      
+      entity = WhowishWord.new
+      entity.word_id = params[:word_id].strip
+      entity.content = params[:content].strip
+
+    end
+
+    entity.word_id = params[:word_id].strip
+    entity.content = params[:content].strip
+    entity.save
+
+    ActionView::Base.whowish_word[entity.word_id] = entity.content
+    
+    render :json=>{:ok=>true}
+  end
+  
+  def add
+    
+    entity = WhowishWord.new
+    entity.word_id = params[:word_id].strip
+    entity.content = params[:content].strip
+    
+    if !entity.save
+      render :json => {:ok=>false, :error_message=>format_error(entity.errors)}
+      return
+    end
+    
+    render :json=>{:ok=>true ,:new_row=>render_to_string(:partial=>"row.html",:locals=>{:entity=>entity,:field_set=>SHOW_FIELDS,:is_new=>false}), :entity=> entity}
+    
+  end
+  
+  def delete
+
+    if !WhowishWord.delete(params[:id])
+      render :json=>{:ok=>false,:error_message=>"error while delete location"}
+      return
+    end
+ 
+    render :json=>{:ok=>true}
+  end
+end

data/lib/legacy/whowish_word/lib/app/controllers/whowish_word_email_controller.rb

@@ -0,0 +1,66 @@
+class WhowishWordEmailController < ActionController::Base
+  
+  before_filter :compact_policy,:check_whowish_word_admin
+  
+  def check_whowish_word_admin
+    $whowish_word_admin = session[:whowish_word_admin]
+  end
+  
+  def compact_policy
+    response.headers['P3P'] = 'policyref="/w3c/p3p.xml", CP="'+COMPACT_POLICY+'"'
+  end
+  
+  layout "whowish_word_blank"
+
+  def index
+
+  end
+
+  def add
+
+    email = WhowishWordEmail.new
+    email.page_id = params[:page_id].strip
+    email.word_id = params[:word_id].strip
+    email.content = params[:content].strip
+    email.locale = "en"
+
+    email.save
+
+    ActionView::Base.whowish_word[entity.page_id] = {} if !ActionView::Base.whowish_word[entity.page_id]
+    ActionView::Base.whowish_word[entity.page_id][entity.word_id.to_sym] = entity.content
+
+    render :json=>{:ok=>true,:html=>(render_to_string :partial=>"row",:locals=>{:entity=>email,:is_new=>false})}
+  end
+
+  def edit
+
+    entity = WhowishWordEmail.first(:conditions=>{:id=>params[:id]})
+
+    if !entity
+      render :json=>{:ok=>false,:error_message=>"The email record does not exist."}
+      return
+    end
+
+    entity.page_id = params[:page_id].strip
+    entity.word_id = params[:word_id].strip
+    entity.content = params[:content].strip
+    entity.locale = "en"
+
+    ActionView::Base.whowish_word[entity.page_id] = {} if !ActionView::Base.whowish_word[entity.page_id]
+    ActionView::Base.whowish_word[entity.page_id][entity.word_id.to_sym] = entity.content
+
+    entity.save
+
+    render :json=>{:ok=>true}
+  end
+
+  def delete
+    if !WhowishWordEmail.delete(params[:id])
+      render :json=>{:ok=>false,:error_message=>"error while delete location"}
+      return
+    end
+
+    render :json=>{:ok=>true}
+  end
+
+end

data/lib/legacy/whowish_word/lib/app/controllers/whowish_word_facebook_controller.rb

@@ -0,0 +1,62 @@
+class WhowishWordFacebookController < ActionController::Base
+  
+  before_filter :compact_policy,:check_whowish_word_admin
+  
+  def check_whowish_word_admin
+    $whowish_word_admin = session[:whowish_word_admin]
+  end
+  
+  def compact_policy
+    response.headers['P3P'] = 'policyref="/w3c/p3p.xml", CP="'+COMPACT_POLICY+'"'
+  end
+  
+  layout "whowish_word_blank"
+
+
+  def index
+
+  end
+
+  def add
+
+    facebook = WhowishWordFacebook.new(:publish_id=>params[:publish_id].strip,
+                                       :message=>params[:message].strip,
+                                       :name=>params[:name].strip,
+                                       :caption=>params[:caption].strip,
+                                       :description=>params[:description].strip,
+                                       :locale=>"en"
+                                      )
+    facebook.save
+
+    render :json=>{:ok=>true,:html=>(render_to_string :partial=>"row",:locals=>{:entity=>facebook,:is_new=>false})}
+  end
+
+  def edit
+
+    facebook = WhowishWordFacebook.first(:conditions=>{:id=>params[:id]})
+
+    if !facebook
+      render :json=>{:ok=>false,:error_message=>"The facebook record does not exist."}
+      return
+    end
+
+    facebook.update_attributes(:publish_id=>params[:publish_id].strip,
+                                       :message=>params[:message].strip,
+                                       :name=>params[:name].strip,
+                                       :caption=>params[:caption].strip,
+                                       :description=>params[:description].strip,
+                                       :locale=>"en"
+                            )
+
+    render :json=>{:ok=>true}
+  end
+
+  def delete
+    if !WhowishWordFacebook.delete(params[:id])
+      render :json=>{:ok=>false,:error_message=>"error while delete location"}
+      return
+    end
+
+    render :json=>{:ok=>true}
+  end
+end