RubyGems - rtml - Versions diffs - 1.2.2 → 2.0.0.alpha.1 - Mend

rtml 1.2.2 → 2.0.0.alpha.1

Files changed (584) hide show

data/app_generators/rtml/templates/rails_template.rb DELETED

@@ -1,36 +0,0 @@
-def win_env?
-  RUBY_PLATFORM=~ /(win32|mingw)/
-end
-def rake(command, options = {})
-  env = options[:env] || 'development'
-  log 'rake', "#{command} in #{env} "
-  sudo = win_env? ? '' : (options[:sudo] ? 'sudo' : '')
-  rake_cmd = win_env? ? "rake.bat" : 'rake'
-  in_root { run("#{sudo} #{rake_cmd} #{command} RAILS_ENV=#{env}", false) }
-end
-inside("vendor/plugins/rtml") do
-  run "ruby install.rb"
-end
-run "rm public/index.html"
-gem "hpricot"
-rake "gems:install"
-rake 'rtml:setup'
-rake 'db:migrate'
-rake 'db:test:load'
-controller_name = ask("Controller name [skip]: ").chomp
-if controller_name.length > 0
-  controller_name.gsub!(/_./) { |i| i[1].chr.upcase }
-  actions = ask("Actions (separate with space) [index]: ").chomp.split(/\s/)
-  actions = [ 'index' ] if actions.length == 0
-  default_action = ((actions.include? "index") ? "index" : actions.first)
-end
-if controller_name.length > 0
-  run "ruby script/generate rtml_controller #{controller_name} #{actions.join(" ")}"
-  route "map.connect_rtml :controller => '#{controller_name}', :action => '#{default_action}'"
-else
-  route 'map.connect_rtml'
-end

data/app_generators/rtml/templates/rtml/MIT-LICENSE DELETED

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Colin MacKenzie IV
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/app_generators/rtml/templates/rtml/README DELETED

@@ -1,109 +0,0 @@
-RTML (RubyTML) is a TML syntax for Ruby. (Redundant, huh?)
-RTML hails from very humble beginnings. Originally, it was designed to
-help new TML programmers understand just how the TML is being processed.
-TML has its similarities to HTML, except that it's about 10 times harder
-for a newbie to figure out what it means. My aim was to keep the language
-as simple as possible to understand, while keeping to an identical work
-flow, so that anyone learning the RTML would be able to take that directly
-into TML when the time came. (Ruby on Rails was considered an unlikely
-candidate for a production TML server at the time, so people had to be able
-to take what they learned from this into Java or PHP -- which means typing
-a lot of raw TML.)
-I think I did too good a job on the work flow thing, though, because I found
-myself writing code over and over again, just like TML. Sure, it was easier to
-read than raw TML would have been, but it was so wordy! I had a bit of a
-lightbulb moment, realizing that basic TML flies in the face of the DRY (Don't
-Repeat Yourself) principle, which is a cornerstone of Rails development,
-and I also realized that I could get so much more accomplished if I took the
-Rails principles and applied them to TML. It was just a collection of helper
-methods, really.
-Then, after the basic functionality was there, I had another lightbulb
-moment. I looked at the Rails framework and what it had become, and thought,
-why not do for TML what Rails has done for HTML? So I started writing
-supporting classes for it -- the TMLAppController, some helpers, Widgets,
-some generators and rake tasks... The list goes on. RTML has come a long
-way since its inception.
-RTML makes a concerted effort to make the application read like
-a human language. This is why Ruby was chosen as the base language of choice:
-because Ruby is already pretty easy to read, as programming languages go.
-It's not perfect, of course, but it's getting close.
-What RTML is NOT:
-RTML is not a complete substitute for standard Terminal Markup Language (TML).
-It reformats Ruby-style code into its TML counterpart, which is then sent to
-the terminal browser.
-RTML is not an IDE. RTML can even be written in Notepad, if you have the
-stomach for it. It is simply a Ruby interface into the TML world.
-RTML is not a replacement for the TML logic flow. That is, RTML will not
-replace the entire TML development process. TML, in its simplest form, looks
-something like:
-  Idle prompt -> User Input -> Screen -> User Input -> [Send data, receive data]
-  						-> Completion / back to Idle Prompt.
-This flow is exactly the same whether you design an application using RTML or
-standard TML.
-Here is an example of the GMA event processing code found on page 34
-of the TML Application Development Guidelines for Incendo, rewritten as an
-RTML action:
-	Rtml::actions_for MyTMLApplication do
-		on :menu => :initialscr, :cancel => :initialscr
-		includes '/btmlpa/tmlapp.tml'
-		includes '/magcard/magcard.tml'
-		includes '/iccemv/iccemv.tml'
-		screen :initialscr, :next => :initialscr1 do
-			next_screen '/magcard/magcard.tml', :if => "tmlvar:gma.event.occured == mag"
-			next_screen '/iccemv/iccemv.tml',   :if => "tmlvar:gma.event.occured == icc"
-		end
-		screen :initialscr1 do
-			on :cancel => :initialscr1
-			display # The actual display code is segregated into a Rails view. See below.
-		end
-		screen :gma_subscr, :next => :initialscr1 do
-			set 'gma.event.subscribed' => 'anykey;mag;icc'
-		end
-		screen :gma_unsubscr, :next => :initialscr1 do
-			set 'gma.event.subscribed' => ''
-		end
-	end
-Notice the :initialscr1 screen has "display" in it. This tells RTML to
-render the View for that screen. Display can be called with an argument,
-too, to override this behavior: A String will be assigned directly, or
-a Block can be added to facilitate additional functionality.
-For this example, the View looks like this:
-		<h1>OE Examples:</h1>
-		<%=link_to "BTMLPA", "/btmlpa/tmlapp.tml"%><br/>
-		<%=link_to "MAGCARD", "/magcard/magcard.tml"%><br/>
-		<%=link_to "ICCEMV", "/iccemv/iccemv.tml"%><br/>
-		<%=link_to "Subscribe to GMA events", :anchor => "#gma_subscr"%><br/>
-		<%=link_to "Unsubscribe from GMA events", :anchor => "#gma_unsubscr"%><br/>
-		<%=link_to "Terminal Config", embedded_app%><br/>
-		<%=link_to "Exit OEBR", "exit"%>
-As you can see, RTML is embedded within an ERB document just like
-any other Embedded Ruby.
-Copyright (c) 2009
-Written by Colin MacKenzie IV
-Released under the MIT license.

data/app_generators/rtml/templates/rtml/Rakefile DELETED

@@ -1,38 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-#require File.join(File.dirname(__FILE__), "lib", "rtml", "version")
-desc 'Default: run unit tests.'
-task :default => :test
-task "test" do |t|
-  Rake::Task['test:all'].invoke
-end
-namespace "test" do |t|
-  desc 'Test the rtml plugin.'
-  [:all, :core, :validation, :functional].each do |s|
-    desc "Test rtml (#{s})"
-    Rake::TestTask.new(s) do |t|
-      case s
-        when :all then t.pattern = "test/**/*.rb"
-        else t.pattern = "test/#{s}/**/*.rb"
-      end
-      #t.libs << 'lib'
-      t.test_files = ["test/rtml_test_helper.rb"]
-      t.verbose = true
-    end
-  end
-end
-desc 'Generate documentation for the rtml plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Rtml'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/app_generators/rtml/templates/rtml/app/controllers/beryl_controller.rb DELETED

@@ -1,70 +0,0 @@
-class BerylController < Rtml::RtmlAppController
-  tml_helper :all, :plugin_path => true # see app/helpers/beryl_tml_helpers/*.rb
-  include Rtml::Features
-  hide_action :authorize
-  configure_features do |config|
-    config.common.menu = false
-  end
-  rtml_debug do |config|
-    config[:dump_tml] = false
-  end
-  def authorize(transaction)
-    logger.warn "You should override BerylController#authorize(transaction)"
-    logger.warn "Default implementation always sends a fake approval."
-    logger.debug "Transaction information:"
-    logger.debug transaction.to_yaml
-    transaction.message = "APPROVED"
-    transaction.auth_code = Time.now.to_i + rand(99999)
-    transaction.state = :approved
-  end
-  def sale
-    auth Rtml::Transaction.from(params)
-  end
-  def sale_return
-    auth Rtml::Transaction.from(params)
-  end
-  def force_sale
-    auth Rtml::Transaction.from(params)
-  end
-  def void
-    auth Rtml::Transaction.from(params)
-  end
-  private
-  def auth(transaction)
-    valid_states = (Rtml::Beryl::Constants::States - [:new])
-    started_at = Time.now
-    begin
-      transaction.card.input_type = :keyed if params[:manual_entry].to_s == '1'
-      authorize transaction
-      unless valid_states.include? transaction.state
-        raise "Set transaction.state to one of #{valid_states.inspect}"
-      end
-      transaction.message ||= case transaction.state
-        when :approved then "Transaction approved"
-        when :declined then "Transaction declined"
-        when :failed   then "Transaction failed"
-        when :reversed then "Transaction reversed"
-        when :canceled then "Transaction canceled"
-      end
-    rescue #auth
-      transaction.state = :declined if transaction.state == :new
-      raise
-      #raise "Error in transaction data: \"#{$!}\""
-    end
-    transaction.duration = Time.now.to_f - started_at.to_f
-    transaction.save!
-    @transaction = transaction
-    render :rtml => :auth_result unless performed?
-  end
-end

data/app_generators/rtml/templates/rtml/app/controllers/rtml/magcard_demo_controller.rb DELETED

@@ -1,9 +0,0 @@
-class Rtml::MagcardDemoController < Rtml::RtmlAppController
-  tml_helper :all, :plugin_path => true # see app/helpers/magcard_demo_tml_helpers/*.rb
-  def authorize
-    logger.debug params.to_yaml
-    @auth_code = Time.now.to_i
-    render :rtml => :authorized
-  end
-end

data/app_generators/rtml/templates/rtml/app/controllers/rtml/oe/btmlpa_controller.rb DELETED

@@ -1,158 +0,0 @@
-class Rtml::Oe::BtmlpaController < Rtml::RtmlAppController
-#    $RTML_WIREDUMP_DEV = STDOUT
-#  caches_action :index, :receipt, :icc
-  tml_helper :all, :plugin_path => true
-  include Rtml::Oe
-  include Rtml::Oe::BtmlpaConstants
-  before_filter :find_terminal, :only => [ :auth, :reverse ]
-  public
-  def rescue_action_test
-    raise "Error"
-  end
-  def reverse
-    txn = Rtml::Transaction.find_by_txn_id(params[:transid], :conditions => { :terminal_id => @terminal.id })
-    if txn.nil?
-      raise "Reversal failed: Invalid transaction ID"
-    else
-      case txn.state
-        when State::APPROVED
-          t = txn.txn_type
-          txn.txn_type = TxnType::REVERSAL
-          authorize! txn # Application.getInstance().reverseTransaction(txn)
-          raise "Reversal failed: #{txn.message}" if txn.auth_code.nil?
-          txn.state = State::REVERSED
-          txn.txn_type = t
-          txn.save!
-        when State::NEW
-          txn.state = State::CANCELED
-          txn.save!
-        else
-          puts "FAIL ON GET < #{txn.state}"
-          raise "Reversal failed: Invalid transaction state"
-      end
-    end
-    @message = "Reversed."
-    @destination = "receipt"
-    render :rtml => :dynamic
-  end
-  def auth
-    puts params.to_yaml
-    started_at = Time.now
-    txn = Rtml::Transaction.find_by_txn_id(params[:transid], :conditions => { :terminal_id => @terminal.id })
-    if txn.nil?
-      txn = transaction_class.new(:state => State::NEW,
-                            :txn_started => started_at,
-                            :terminal => @terminal,
-                            :txn_id => params[:transid],
-                            :post_id => params[:post_id],
-                            :txn_mode => params[:oebr][:submit_mode],
-                            :txn_type => txn_type_to_i(params[:payment][:trans_type]),
-                            :term_txn_date => DateTime.parse((params[:payment][:txn_date] || Time.now).to_s).utc,
-                            :post_txn_date => (params[:date] ? DateTime.parse(params[:date].to_s).utc : nil),
-                            :amount => params[:payment][:amount]
-                           )
-      if txn.txn_type == TxnType::SALE_CASHBACK
-        if params[:payment][:amount_other] == Value::NOT_SPECIFIED
-          raise "Cashback amount should be specified."
-        end
-        txn.amount_other = params[:payment][:amount_other]
-      end
-      txn.currency_code = params[:currency_code]
-      txn.pan = params[:card][:pan]
-      txn.cardholder_name = params[:card][:cardholder_name]
-      txn.card_number = params[:card][:issue_number]
-      txn.input_method = params[:card][:input_type]
-      txn.iso2_track = params[:card][:mag][:iso2_track] if params[:card][:mag]
-      txn.expiry_date = params[:card][:expiry_date]
-      txn.start_date = params[:card][:effective_date]
-      if txn.input_method == InputMethod::ICC
-        txn.icc_app  = params[:card][:emv][:aid]
-        txn.icc_aip  = params[:card][:emv][:aip]
-        txn.icc_auc  = params[:card][:emv][:auc]
-        txn.icc_atc  = params[:card][:emv][:atc]
-        txn.icc_aac  = params[:card][:emv][:aac]
-        txn.icc_tc   = params[:card][:emv][:tc]
-        txn.icc_arqc = params[:card][:emv][:arqc]
-        txn.icc_iad  = params[:card][:emv][:iad].to_s
-        txn.icc_tvr  = params[:card][:emv][:tvr]
-        txn.icc_unumber = params[:card][:emv][:unumber]
-      end
-      txn.save!
-    else
-      txn.post_id = params[:post_id] if params[:post_id]
-#      if txn.post_id != params[:post_id]
-#        raise "Transaction has a duplicate ID."
-#      end
-      txn.txn_mode = "offline"
-      txn.save!
-    end
-    if txn.state == State::NEW
-      begin
-        authorize! txn
-        txn.state = (txn.auth_code ? State::APPROVED : State::DECLINED)
-        puts "SET > #{txn.state}"
-      rescue
-        txn.state = State::DECLINED
-        puts "Error in transaction data: #{$!}"
-        puts $!.backtrace[0..4].join("\n")
-        raise "Error in transaction data: \"#{$!}\""#"Incorrect data."
-      end
-      txn.txn_duration = (Time.now.to_i - started_at.to_i)
-      txn.save!
-    end
-    unless offline?
-      # do stuff w/ auth result stuff
-    end
-    @transaction = txn
-    auth_result
-  end
-  protected
-  # Commence transaction authorization
-  # You should override this in your controller.
-  def authorize!(transaction)
-    raise "Default method Rtml::Oe::BtmlpaController#authorize! is not implemented"
-  end
-  def transaction_class
-    self.class.name.gsub(/Controller/, "Transaction").constantize rescue \
-      self.class.name.gsub(/Controller/, '::Transaction').constantize rescue \
-      Rtml::Transaction
-  end
-  private
-  def find_terminal
-    Rtml::Terminal
-    Rtml::Transaction
-#    Examples::Btmlpa::Terminal
-#    Examples::Btmlpa::Transaction
-    @terminal = Rtml::Terminal.find_by_itid(params[:itid])
-    @terminal = Rtml::Terminal.create!(:itid => params[:itid]) if @terminal.nil?
-    #raise "Terminal ITID not found: #{params[:itid]}" if @terminal.nil?
-  end
-  def txn_type_to_i(type)
-    case type.to_s.downcase
-      when "debit" then return 1
-      when "cashback" then return 2
-      when "credit" then return 3
-      when "reversal" then return 1
-      else raise "Unsupported payment type: #{type}"
-    end
-  end
-  def offline?
-    params[:oebr][:submit_mode].to_s.downcase == "offline"
-  end
-end