da_funk 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90a9a5f13e7351436d38420ccf9e99ca4919f56c
-  data.tar.gz: c7745e68dbcf4fc145ca67cfc2c472cba6be8eda
+  metadata.gz: 0126b30dd3adddbd22dafdc3a478ecba668298c5
+  data.tar.gz: b8b4ed57370dde40c82323491769c29ba6ad36fd
 SHA512:
-  metadata.gz: 8ec253d98c010406b4d58f7590e5b54345db4fbe6384a049470b8aa2ceb8c599bef0cbef558010ded38e72f83d8712dfe3b4206863f47fc92253e0ef67151999
-  data.tar.gz: a723618fd4326f4788bd32b90a2be7b7fac2e085b9ed622027555b23efa6fcf6a6641c72d7df9f9bb15f356cf94b127c9d8cb8f0c55b12eb88da2777e5d4b921
+  metadata.gz: 04a5c2935a6a4a9c39cb31a45e088afec3625f18b1cb1a317e4c237db3b7e141b7152ee5c61a42b2bf6841c8eeb3103864a283f65152281eee97a030c06820eb
+  data.tar.gz: a4cfcd1395e0dade008fbf37326edaae6d738a2785cae0677d060446da0589c8bdd929f28474f61b708ff7f09d625c254f466b87daf7faad8ef8c1fad6342bbf

data/Gemfile.lock

@@ -7,7 +7,7 @@ GIT
 PATH
   remote: .
   specs:
-    da_funk (0.5.4)
+    da_funk (0.6.0)
       bundler (~> 1.7)
       cloudwalk_handshake (~> 0.5)
       posxml_parser (~> 0.6)
@@ -17,9 +17,9 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    cloudwalk_handshake (0.5.0)
-    posxml_parser (0.6.1)
-    rake (10.4.2)
+    cloudwalk_handshake (0.5.1)
+    posxml_parser (0.7.1)
+    rake (10.5.0)
     yard (0.8.7.6)
 
 PLATFORMS

data/README.md

@@ -1,102 +1,180 @@
-# DaFunk
+# DaFunk, a.k.a. CloudWalk Framework API
 
-Walk Framework API, responsible for managed compatibility between implemented devices, and treat deprecated syntax or behaviour.
+Our goal at [CloudWalk][1] is to provide you with the
+necessary tools to build Point Of Sales (POS) applications
+in an easy and innovative way. To do so, we've developed
+a setup for MRuby programs that allows you to build and
+ship modern day applications to all of your terminals
+instantaneously. For that purpose, you will need to start
+using the API that is provided by this repository.
 
-## Setup
+## Index
+
+- [Index](#index)
+- [What do I have here?](#what-do-i-have-here)
+- [How do I use this?](#how-do-i-use-this)
+- [Adding support to other platforms](#adding-support-to-other-platforms)
+- [I would like to contribute](#i-would-like-to-contribute)
+
+## What do I have here?
+
+This repository contains a set of files and folder that compose the
+**CloudWalk Framework API**. The structure goes as follows:
+
+- The `guides` directory, which contains a group of files that are intended to instruct how to use our framework.
+- An `imgs` directory, containing a picture that references the creative origins of this project.
+- A `lib` directory, which holds the main source code of our Framework API.
+- An `out`directory, which has a previous generated binary of this project. All builds target this directory.
+- A `test` directory with example test cases. Tests are divided by _integration_ tests and _unit_ tests.
+- A `utils` folder that contains some scripts which are useful for us to perform tests or interact with the command line environment.
+
+## How do I use this?
+
+We strongly recommend using our framework API from our [application skeleton][3],
+it has all the minimal files and the structure needed to build your first application.
 
-1. Install Ruby 1.9.3 (mruby compatible)
+Essentially add to your `Gemfile`:
 
-2. Bundle `$ bundle install`
+```ruby
+gem 'da_funk', :git => 'https://github.com/cloudwalkio/da_funk.git'
+```
 
-## Load
+Then require `da_funk` in your application file!
 
-### All 
-    require 'da_funk'
+```ruby
+require 'da_funk'
+```
 
-### Only ISO8583 module 
+For more advanced users only wanting to use the `iso8583` module, here's how you require it:
 
-    require 'da_funk/iso8583'
+```ruby
+require 'da_funk/iso8583'
+```
 
-	
-## Docs (yard)
+A full tutorial on how to develop your first CloudWalk app
+can be found here: <https://docs.cloudwalk.io/en/cli>,
+or checkout this project's source code!
 
-1. Generate: `$ rake yard`
-2. Open: `open docs/index.html`
+## Adding support to other platforms
 
-## How to create Device
+At CloudWalk we develop our framework targeting several POS terminal brands,
+physical devices and even virtual devices (such as our web emulator).
+To deal with the platform differences, we've created an abstraction layer
+in da_funk that helps us modify our framework's behavior for our targets,
+but ensuring the changes needed are minimal and separated from the
+framework's source code. As an example, we offer our project:
+[around_the_world][4], it is the recipe to have MRuby working on
+non embedded platforms and with full compliance with DaFunk API.
 
-### Steps
+The first step is to add `da_funk` as a submodule in your project, let's say you'll be hosting it on a git server,
+proceed with:
 
-1. Add da_funk as submodule of your platform project, check the sample  [here](https://github.com/cloudwalkio/around_the_world) `$ git submodule add git@github.com:cloudwalkio/da_funk.git <path/to/lib/da_funk>`
+    git submodule add git@github.com:cloudwalkio/da_funk.git path/to/lib/da_funk
 
-2. Develop setup method in platform abstraction.
+Then, in your application, before starting anything, define your
+platform interface. The most important feature it needs to have is
+a `setup` method, which will be called to configure and initialize
+everything before the actual execution.
+
+```ruby
+class PlatformInterface
+  def self.setup
+    # Configuration and initialization before apps execution
+  end
+end
+```
+
+Then you'll need to define your custom classes, but following the structure
+present in our [device][5] source code. These classes can be in the same file
+as the one that has the setup method, here is an example:
+
+```ruby
+class PlatformInterface
+  Network = ::Network # Implemented on C
+  IO      = ::IO # Implemeted on C
+
+  class Display
+    def self.clear
+      ::IO.display_clear
+    end
+
+    def self.print_line(buf, row, column)
+      # <class created on C or PlatformInterface>._print_line(buf, row, column)
+      PlatformInterface._print_line(buf, row, column)
+    end
+  end
+end
+```
 
-	Setup method will be called in every app execution, should be use to filesystem preparation or any shore needed by the app environment. Check the sample [here](https://github.com/cloudwalkio/mruby-cloudwalk-platform).
+Some important notes regarding your platform interface:
 
-		class PlatformInterface
-		    def self.setup
-		        # Configuration and initialization before apps execution
-		    end
-		end
-		
-3. Develop interface required by DaFunk on PlatformInterface, could be the same file you have setup method.
+- Be careful with the instance object variable, leave that for DaFunk.
+- Put preference into using class methods instead of making calls as the interface.
+- We might revise this in the future, but for now: any method defined for
+  platform-specific usages has to be defined with a name that starts with `_`,
+  for example: `_myMethod`.
 
-		class PlatformInterface
-			Network = ::Network # Implemented on C
-			IO      = ::IO # Implemeted on C
+Once you're comfortable with your platform class,
+we need to set it up as the adapter to use by altering DaFunk's device class:
 
-			class Display
-				def self.clear
-					::IO.display_clear
-				end
-				
-				def self.print_line(buf, row, column)
-					# <class created on C or PlatformInterface>._print_line(buf, row, column)
-					PlatformInterface._print_line(buf, row, column)
-				end
-			end
-		end
+```ruby
+class Device # Class from DaFunk
+  self.adapter = PlatformInterface
+end
+```
+
+The adapter pattern is based is a well studied software design pattern,
+we recommend you to read the [Wiki article][7], it's an interesting bit
+of information that is rooted deep in our solutions.
 
-4. Configure Adapter
+Finally build it with `rake` or in a more specific manner, with: `mrbc -o platform.mrb </path/to/mrblib/**/*/.rb>`
 
-		class Device # Class from DaFunk
-			self.adapter = PlatformInterface
-		end
+In [this link][6] there is an example of the whole process. Enjoy the reading! :bowtie:
+
+## I would like to contribute
 
-5. Compile da_funk into mrb file `$ rake`.
-6. Compile platform abstraction into mrb file `$ mrbc -o platform.mrb </path/to/mrblib/**/*/.rb`
-7. Application file `main.rb`(could be use to test).
-
-		class Main
-			def self.call
-				Device::Display.print "Test"
-			end
-		end
-
-	Call method should be implemented on applications.
-
-
-### Adapter pattern
-Adapter(platform abstraction) should be configured to access by DaFunk Library
-
-- [Wiki](http://en.wikipedia.org/wiki/Adapter_pattern)
-- Scheme Image (todo)
-
-
-### Platform Interface
-
-- Be careful with instance object variable, let't for DaFunk.
-- Prefer class methods to call as interface.
-- Any method defined on platform language, access by PlatformAbstraction, should defined with _<method name>. # Revise this point
-
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-
-![DaFunk](imgs/daft-punk-da-funk.jpg)
+So, you want to propose changes to our skeleton??!! Thank you sir! We appreciate it :bowtie:
+
+Please follow the instructions:
+
+1. Fork it under your github account!
+2. Create your feature branch `git checkout -b my-new-feature`
+3. Commit your changes `git commit -am 'Added some feature'`
+4. Push to the branch `git push origin my-new-feature`
+5. Create a new Pull Request!
+
+## License
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2015 CloudWalk, Inc.
+
+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.
+```
+
+[1]: https://www.cloudwalk.io
+[2]: https://www.cloudwalk.io/cli/
+[3]: https://github.com/cloudwalkio/cloudwalk-skeleton
+[4]: https://github.com/cloudwalkio/around_the_world
+[5]: https://github.com/cloudwalkio/da_funk/tree/master/lib/device
+[6]: https://github.com/cloudwalkio/mruby-cloudwalk-platform
+[7]: https://en.wikipedia.org/wiki/Adapter_pattern
+
+![DaFunk](https://raw.githubusercontent.com/cloudwalkio/da_funk/master/imgs/daft-punk-da-funk.jpg)

data/RELEASE_NOTES.md

@@ -1,5 +1,24 @@
 # DaFunk
 
+### 0.6.0 - 2016-02-02 - Support to i18n.
+- Add support to i18n.
+- Add I18n messages to ParamsDat/Files/Apps downloading.
+- Add support to ISO8583 file parser.
+- Implemented DaFunk::Helper#try_keys to abstract a helper responsible to wait for range of key only in a period.
+- Implement classes CallbackFlow and ScreenFlow to abstract the development of complex screen flows.
+- Refactoring Device::IO.get_format.
+- Rjust Device::Crypto.crc16_hex return, 4 chars with “0”.
+- Add support to current value on Device::IO.get_format.
+- Send file CRC on file download.
+- Implement String#integer?.
+- Fix number_to_currency to not include label after conversion.
+- Add pagination on Helper.menu.
+- FileDb always work with key and values as string.
+- Fix System Error during Notification Fiber catching all communication exceptions.
+- Update cloudwalk_handshake version to 0.5.1.
+- Update posxml_parser version to 0.7.1.
+- Update readme file.
+
 ### 0.5.4 - 2016-01-08 - Update posxml_parser
 - Update posxml_parser to version 0.6.1.
 

data/Rakefile

@@ -14,6 +14,11 @@ FILES = FileList[
   "lib/da_funk.rb",
   "lib/da_funk/test.rb",
   "lib/da_funk/screen.rb",
+  "lib/da_funk/callback_flow.rb",
+  "lib/da_funk/screen_flow.rb",
+  "lib/da_funk/i18n_error.rb",
+  "lib/da_funk/i18n.rb",
+  "lib/da_funk/file_parameter.rb",
   "lib/device.rb",
   "lib/device/audio.rb",
   "lib/device/crypto.rb",
@@ -38,6 +43,7 @@ FILES = FileList[
   "lib/iso8583/message.rb",
   "lib/iso8583/util.rb",
   "lib/iso8583/version.rb",
+  "lib/iso8583/file_parser.rb",
   "lib/device/transaction/iso.rb",
   "lib/serfx.rb",
   "lib/serfx/commands.rb",

data/lib/da_funk/callback_flow.rb

@@ -0,0 +1,50 @@
+module DaFunk
+  class CallbackFlow
+    attr_accessor :next
+    attr_reader :block, :before, :bind
+
+    def initialize(bind, callback, &block)
+      @bind   = bind
+      @block  = block
+      @before = callback
+      callback.next = self if callback
+    end
+
+    def dispatch(result)
+      return if result.nil?
+      Device::Display.clear
+      route(check(bind.instance_exec(result, &block)))
+    end
+
+    def check(value)
+      unless [true, nil, false].include?(value)
+        value = check_keyboard(value)
+      end
+      value
+    end
+
+    def route(result)
+      if result
+        if @next
+          @next.dispatch(result)
+        else
+          true
+        end
+      elsif result.nil?
+      else
+        @before.dispatch(true)
+      end
+    end
+
+    private
+    def check_keyboard(value)
+      case value
+      when Device::IO::CANCEL; return nil
+      when Device::IO::BACK; return false
+      when Device::IO::ENTER; return true
+      end
+      true
+    end
+  end
+end
+

data/lib/da_funk/file_parameter.rb

@@ -0,0 +1,70 @@
+module DaFunk
+  class FileParameter
+    FILEPATH = "./shared"
+    attr_accessor :crc
+    attr_reader :name, :file, :crc_local, :original, :remote
+
+    def self.delete(collection)
+      collection.each do |file_|
+        begin
+          file_.delete
+        rescue RuntimeError
+        end
+      end
+    end
+
+    def initialize(name, crc)
+      @crc      = crc
+      @original = name
+      @remote   = @original.sub("#{Device::Setting.company_name}_", "")
+      @name     = @original.sub("#{Device::Setting.company_name}_", "").split(".").first
+      @file     = "#{FILEPATH}/#{@remote}"
+      @crc_local = @crc if File.exists?(@file)
+    end
+
+    def zip?
+      @original.to_s[-4..-1] == ".zip"
+    end
+
+    def exists?
+      File.exists? @file
+    end
+
+    def unzip
+      if zip? && exists?
+        Zip.uncompress(file, FILEPATH, false, false)
+      end
+    end
+
+    def download(force = false)
+      if force || outdated?
+        ret = Device::Transaction::Download.request_file(remote, file, crc_local)
+      else
+        ret = Device::Transaction::Download::FILE_NOT_CHANGE
+      end
+      @crc_local = @crc if ret == Device::Transaction::Download::SUCCESS
+      ret
+    end
+
+    def delete
+      File.delete(self.file) if exists?
+    end
+
+    def outdated?
+      return true unless exists?
+      unless @crc_local
+        handle = File.open(file)
+        @crc_local = Device::Crypto.crc16_hex(handle.read)
+      end
+      @crc_local != @crc
+    ensure
+      handle.close if handle
+    end
+
+    private
+    def remove_company(name)
+      name.split("_")[1..-1].join("_")
+    end
+  end
+end
+