walrus-rb 0.10.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad98e5ed9edf4b7179704ef6eb50bf2774372c5f
+  data.tar.gz: 563007daa6fe9274d355dba8c170dfabd296a99c
+SHA512:
+  metadata.gz: bf7baf99e2572a229b5f8ba94b8bdfe169cddfddf36ca1e2a2b46309b5bd32496ef8b04a93193e33698a562cfcaf79d85a006e36ef24ae37f9f2dcaa5bf3fe3f
+  data.tar.gz: 2f58c35f10cd182c193f2bf8136cc0d0469d22b80207e57eba3ea97a6926da5e49272abf52ca46a26f96c4d6a5696fadb9abcb27631e5362af61026baf119eef

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in walrus.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,15 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'spork', :rspec_env => { 'RAILS_ENV' => 'test' } do
+  watch('Gemfile')
+  watch('Guardfile')
+  watch('Gemfile.lock')
+  watch('spec/spec_helper.rb') { :rspec }
+  watch(%r{^spec/support/.+\.rb$})
+  watch(%r{^lib/digital_opera/(.+)\.rb$}) { :rspec }
+end
+
+guard :rspec, :all_after_pass => false, :all_on_start => false, :cli => '--drb' do
+  watch(%r{^spec/.+_spec\.rb$})
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 DIGITALOPERA, LLC
+
+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/README.md

@@ -0,0 +1,45 @@
+# walrus-rb
+
+Uses the actual JavaScript implementation of [walrus.js](https://github.com/jeremyruppel/walrus), but supports using Ruby objects as template contexts and Ruby procs as view functions and domain objects
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'walrus-rb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install walrus-rb
+
+## Current Walrus.js Version
+
+    walrus 0.10.1
+
+## Config
+
+By default, only the core Walrus library is loaded. To load additional helpers:
+
+    Walrus.configure do |config|
+      config.helper_files = ['collections','currencies','dates','inflections','math','strings']
+    end
+
+You can also load domain objects
+
+    Walrus.configure do |config|
+      config.domain_objects_file = File.expand_path("../walrus_domain_objects.js", __FILE__)
+    end
+    
+An example domain_objects.js file can be found [here](https://github.com/digitalopera/walrus-rb/blob/master/spec/support/javascripts/walrus_domain_objects.js)
+
+## Contributing
+
+1. Fork it ( http://github.com/digitalopera/walrus-rb/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new
+task :default => :spec
+

data/lib/walrus.rb

@@ -0,0 +1,7 @@
+require "walrus/version"
+require 'walrus/config'
+require 'walrus/context'
+
+module Walrus
+  extend Config
+end

data/lib/walrus/config.rb

@@ -0,0 +1,29 @@
+module Walrus
+  # Change config options in an initializer:
+  #
+  # Walrus.domain_objects_file = 'domain_objects.js'
+  #
+  # Or in a block:
+  #
+  # Walrus.configure do |config|
+  #   config.domain_objects_file = 'domain_objects.js'
+  # end
+
+  module Config
+    extend self
+
+    attr_writer :domain_objects_file, :helper_files
+
+    def configure
+      yield self
+    end
+
+    def domain_objects_file
+      @domain_objects_file ||= ''
+    end
+
+    def helper_files
+      @helper_files ||= []
+    end
+  end
+end

data/lib/walrus/context.rb

@@ -0,0 +1,42 @@
+require 'v8'
+
+module Walrus
+  class Context
+    def initialize
+      @js = V8::Context.new
+
+      # load core file
+      self.load_js File.expand_path("../../../vendor/walrus.js", __FILE__)
+
+      # load additional files
+      Walrus.helper_files.each do |name|
+        self.load_js File.expand_path("../../../vendor/walrus.#{name}.js", __FILE__)
+      end
+
+      # load domain_objects_file is supplied
+      unless Walrus.domain_objects_file.empty?
+        self.load_js Walrus.domain_objects_file
+      end
+
+      return self
+    end
+
+    def parse(*args)
+      @template = walrus.Parser.parse(*args)
+
+      return self
+    end
+
+    def compile(object={})
+      @template.compile(object)
+    end
+
+    def walrus
+      @js.eval('Walrus')
+    end
+
+    def load_js(file_path)
+      @js.load(file_path)
+    end
+  end
+end

data/lib/walrus/version.rb

@@ -0,0 +1,3 @@
+module Walrus
+  VERSION = "0.10.1.0"
+end

data/spec/blocks_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Blocks/Helpers' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile({isTrue: true}) }
+  let(:str){ '{{:if @isTrue do}}in if{{end}}' }
+
+  describe ':if' do
+    it 'should render' do
+      compile.should eq 'in if'
+    end
+  end
+end

data/spec/collections_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'collections' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile(numbers) }
+  let(:numbers){ {numbers: [{name:'Bob'},{name: 'Jim'}]} }
+
+  describe ':last' do
+    let(:str){ '{{ :each numbers | :last do }}{{name}}{{end}}' }
+
+    it 'should render' do
+      compile.should eq 'Jim'
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Context' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile }
+  let(:str){ '{{@name}}' }
+
+  context 'when compile was not passed data' do
+    it 'should not raise error' do
+      expect{ compile }.to_not raise_error
+    end
+  end
+end

data/spec/currencies_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Currencies' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile({isTrue: true}) }
+  let(:str){ '{{ 36000 | :currency }}' }
+
+  describe ':currency' do
+    it 'should render' do
+      compile.should eq '$36,000.00'
+    end
+  end
+end

data/spec/dates_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Dates' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile({created_at: '12/12/2001' }) }
+  let(:str){ "{{created_at | :strftime( '%F' )}}" }
+
+  describe ':strftime' do
+    it 'should render' do
+      compile.should eq '2001-12-12'
+    end
+  end
+end

data/spec/domain_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Domain' do
+  let(:context){ Walrus::Context.new }
+  let(:template){ context.parse(str) }
+  let(:compile) do
+    template.compile({
+      employees: [
+        {firstName: 'Jim', lastName: 'Johnson'}
+      ]
+    })
+  end
+  let(:str){ '{{:each employees | :as( "person" ) do}}{{fullName()}}{{end}}' }
+
+  it 'should render' do
+    # context.load_js(File.expand_path("../support/javascripts/walrus_domain_objects.js", __FILE__))
+
+    compile.should eq 'Jim Johnson'
+  end
+end

data/spec/filters_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Filters' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile({isTrue: true}) }
+  let(:str){ '{{:if @isTrue | :equals(true) do}}in if{{end}}' }
+
+  describe ':equals' do
+    it 'should render' do
+      compile.should eq 'in if'
+    end
+  end
+end

data/spec/inflections_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'inflections' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile }
+  let(:str){ "{{ 'book' | :pluralize }}" }
+
+  describe ':strftime' do
+    it 'should render' do
+      compile.should eq 'books'
+    end
+  end
+end

data/spec/math_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'math' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile }
+
+  describe ':last' do
+    let(:str){ '{{ 15 | :plus( 6 ) }}' }
+
+    it 'should render' do
+      compile.should eq '21'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+require 'rubygems'
+require 'spork'
+require 'walrus'
+
+Spork.prefork do
+  require 'rspec/autorun'
+  require 'mocha/api'
+
+  # Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+  # Configure RSpec ---------------------------------------
+  RSpec.configure do |config|
+    config.mock_framework = :mocha
+
+    # Run specs in random order to surface order dependencies. If you find an
+    # order dependency and want to debug it, you can fix the order by providing
+    # the seed, which is printed after each run.
+    #     --seed 1234
+    config.order = "random"
+    # config.order = 63206
+  end
+
+
+  Walrus.configure do |config|
+    config.domain_objects_file = File.expand_path("../support/javascripts/walrus_domain_objects.js", __FILE__)
+    config.helper_files = ['collections','currencies','dates','inflections','math','strings']
+  end
+end
+
+Spork.each_run do
+
+end

data/spec/strings_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'Strings' do
+  let(:template){ Walrus::Context.new.parse(str) }
+  let(:compile){ template.compile }
+  let(:str){ '{{ "hello" | :reverse }}' }
+
+  it 'should render' do
+    compile.should eq 'olleh'
+  end
+end

data/spec/support/javascripts/walrus_domain_objects.js

@@ -0,0 +1,22 @@
+// Walrus.Domain.person = {
+//   fullName: function(){
+//     return this.firstName + ' ' + this.lastName;
+//   }
+// }
+
+(function(){
+  objects = {
+    person: {
+      fullName: function(){
+        return this.firstName + ' ' + this.lastName;
+      }
+    }
+  };
+
+  for (key in objects){
+    if (objects.hasOwnProperty(key)) {
+      Walrus.Domain[key] = objects[key];
+    }
+  }
+
+})();

data/vendor/walrus.collections.js

@@ -0,0 +1,234 @@
+(function() {
+  var Walrus;
+
+  Walrus = (typeof exports !== "undefined" && exports !== null ? require('./walrus') : this).Walrus;
+
+  /**
+   * *:first*
+   * Selects the first _count_ items of the array. Defaults to only the first item.
+   *
+   * Parameters:
+   *  count - Optional: how many items to include
+   *
+   * Usage:
+   *
+   *  {{ :each numbers | :first do}}
+   *    // 1
+   *  {{ end }}
+   *
+   *  {{ :each numbers | :first( 5 ) do }}
+   *    // 1 2 3 4 5
+   *  {{ end }}
+  */
+
+  Walrus.addFilter('first', function(array, count) {
+    if (count != null) {
+      return array.slice(0, count);
+    } else {
+      return array[0];
+    }
+  });
+
+  /**
+   * *:last*
+   * Selects the last _count_ items of the array. Defaults to only the last item.
+   *
+   * Parameters:
+   *  count - Optional: how many items to include
+   *
+   * Usage:
+   *
+   *  {{ :each numbers | :last do}}
+   *    // 10
+   *  {{ end }}
+   *
+   *  {{ :each numbers | :last( 5 ) do }}
+   *    // 6 7 8 9 10
+   *  {{ end }}
+  */
+
+  Walrus.addFilter('last', function(array, count) {
+    if (count != null) {
+      return array.slice(-count);
+    } else {
+      return array[array.length - 1];
+    }
+  });
+
+  /**
+   * *:after*
+   * Selects all of the items in the array except for the first _count_.
+   *
+   * Parameters:
+   *  count - how many items to omit from the beginning
+   *
+   * Usage:
+   *
+   *  {{ :each numbers | :after( 3 ) do }}
+   *    // 4 5 6 7 8 9 10
+   *  {{ end }}
+  */
+
+  Walrus.addFilter('after', function(array, count) {
+    return array.slice(count);
+  });
+
+  /**
+   * *:before*
+   * Selects all of the items in the array except for the last _count_.
+   *
+   * Parameters:
+   *  count - how many items to omit from the end
+   *
+   * Usage:
+   *
+   *  {{ :each numbers | :before( 3 ) do }}
+   *    // 1 2 3 4 5 6 7
+   *  {{ end }}
+  */
+
+  Walrus.addFilter('before', function(array, count) {
+    return array.slice(0, -count);
+  });
+
+  /**
+   * *:count*
+   * Returns the length of the given array.
+   *
+   * Parameters: none
+   *
+   * Usage:
+   *
+   *  var numbers = [ 1, 2, 3, 4, 5 ];
+   *
+   *  {{ numbers | :count }} // => 5
+  */
+
+  Walrus.addFilter('count', function(array) {
+    return array.length;
+  });
+
+  /**
+   * *:any*
+   * Returns true if the array is not empty. Opposite of `:empty`.
+   *
+   * Parameters: none
+   *
+   * Usage:
+   *
+   *  var numbers = [ 1, 2, 3, 4, 5 ];
+   *
+   *  {{ numbers | :any }} // => true
+  */
+
+  Walrus.addFilter('any', function(array) {
+    return array.length > 0;
+  });
+
+  /**
+   * *:empty*
+   * Returns true of the array is empty. Opposite of `:any`.
+   *
+   * Parameters: none
+   *
+   * Usage:
+   *
+   *  var numbers = [ 1, 2, 3, 4, 5 ];
+   *
+   *  {{ numbers | :empty }} // => false
+  */
+
+  Walrus.addFilter('empty', function(array) {
+    return array.length === 0;
+  });
+
+  /**
+   * *:join*
+   * Joins an array into a string, optionally with a separator
+   *
+   * Parameters:
+   *  separator - (Optional) string to join on
+   *
+   * Usage:
+   *
+   *  var numbers [ 1, 2, 3 ];
+   *
+   *  {{ numbers | :join }} // => "123"
+   *  {{ numbers | :join( ', ' ) }} // => "1, 2, 3"
+  */
+
+  Walrus.addFilter('join', function(array, separator) {
+    if (separator == null) separator = '';
+    return array.join(separator);
+  });
+
+  /**
+   * *:sort*
+   * Sorts the members of an array, optionally by a specific field
+   *
+   * Parameters:
+   *  field - (Optional) field to compare by
+   *
+   * Usage:
+   *
+   *  var names = [ 'Billy', 'Alex', 'Don' ]
+   *
+   *  {{ names | :sort }} // => [ 'Alex', 'Billy', 'Don' ]
+   *  {{ names | :sort( 'length' ) }} // [ 'Don', 'Billy', 'Alex' ]
+  */
+
+  Walrus.addFilter('sort', function(array, field) {
+    if (field != null) {
+      return array.sort(function(one, two) {
+        return one[field] > two[field];
+      });
+    } else {
+      return array.sort();
+    }
+  });
+
+  /**
+   * *:in_groups_of*
+   * Splits the given array into sub-arrays with at most `count` items apiece
+   *
+   * Parameters:
+   *  count - the number of items to be placed in each group
+   *
+   * Usage:
+   *
+   *  var numbers = [ 1, 2, 3, 4, 5 ];
+   *
+   *  {{ :each numbers | :in_groups_of( 3 ) }} // => [ [ 1, 2, 3 ], [ 4, 5 ] ]
+  */
+
+  Walrus.addFilter('in_groups_of', function(array, count) {
+    return Walrus.Utils.reduce(array, [[]], function(memo, item) {
+      var group;
+      group = memo[memo.length - 1];
+      if (group.length < count) {
+        group.push(item);
+      } else {
+        memo.push([item]);
+      }
+      return memo;
+    });
+  });
+
+  /**
+   * *enumerable* domain methods
+   * TODO document these
+  */
+
+  Walrus.Domain.enumerable = {
+    first: function() {
+      return this['$index'] === 0;
+    },
+    last: function() {
+      return this['$index'] === this['$length'] - 1;
+    },
+    middle: function() {
+      return !(this.first() || this.last());
+    }
+  };
+
+}).call(this);