localio 0.1.7 → 0.2.1

data/lib/localio/templates/swift_constant_localizable.erb

@@ -8,6 +8,19 @@ Created by localio
 
 import Foundation
 
-<% @segments.each do |term| %>
-let <%= term.key %>: String = { return NSLocalizedString("<%= term.translation %>", comment: "") }()<%
+<% 
+node_keys = []
+@segments.each do |term| 
+    if term.key == '[init-node]' or term.key == '[end-node]'
+        node_keys << term.translation if term.key == '[init-node]'
+        node_keys.pop if term.key == '[end-node]'
+    else
+        if node_keys.length() >0
+            key_join = node_keys.join("_").capitalize+"_"+term.key.downcase
+        else
+            key_join = term.key
+        end
+%>
+let kLocale<%= key_join %>: String = { return NSLocalizedString("_<%= key_join %>", comment: "") }()<%
+    end
 end %>

data/lib/localio/version.rb

@@ -1,3 +1,3 @@
 module Localio
-  VERSION = "0.1.7"
+  VERSION = "0.2.1"
 end

data/lib/localio/writers/ios_writer.rb

@@ -25,7 +25,7 @@ class IosWriter
 
         unless term.is_comment?
           constant_key = ios_constant_formatter term.keyword
-          constant_value = key
+          constant_value = translation
           constant_segment = Segment.new(constant_key, constant_value, lang)
           constant_segments.segments << constant_segment
         end
@@ -45,11 +45,11 @@ class IosWriter
   private
 
   def self.ios_key_formatter(key)
-    '_'+key.space_to_underscore.strip_tag.capitalize
+    key.space_to_underscore.strip_tag.capitalize
   end
 
   def self.ios_constant_formatter(key)
-    'kLocale'+key.space_to_underscore.strip_tag.camel_case
+    key.space_to_underscore.strip_tag.camel_case
   end
 
 end

data/lib/localio/writers/swift_writer.rb

@@ -25,7 +25,7 @@ class SwiftWriter
 
         unless term.is_comment?
           constant_key = swift_constant_formatter term.keyword
-          constant_value = key
+          constant_value = translation
           constant_segment = Segment.new(constant_key, constant_value, lang)
           constant_segments.segments << constant_segment
         end
@@ -44,10 +44,10 @@ class SwiftWriter
   private
 
   def self.swift_key_formatter(key)
-    '_'+key.space_to_underscore.strip_tag.capitalize
+     key.space_to_underscore.strip_tag.capitalize
   end
 
   def self.swift_constant_formatter(key)
-    'kLocale'+key.space_to_underscore.strip_tag.camel_case
+    key.space_to_underscore.strip_tag.camel_case
   end
 end

data/lib/localio/writers/twine_writer.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+require 'localio/formatter'
+
+class TwineWriter
+  def self.write(languages, terms, path, formatter, options)
+    puts 'Writing Twine translations...'
+
+    default_language = options[:default_language]
+    output_filename  = options[:output_file] || 'strings.txt'
+
+    FileUtils.mkdir_p(path)
+
+    File.open(File.join(path, output_filename), 'w') do |f|
+      pending_comment = nil
+
+      terms.each do |term|
+        if term.is_comment?
+          pending_comment = term.values[default_language]
+        elsif term.keyword == '[init-node]'
+          f.puts "[[#{term.values[default_language]}]]"
+          pending_comment = nil
+        elsif term.keyword == '[end-node]'
+          f.puts ''
+          pending_comment = nil
+        else
+          key = Formatter.format(term.keyword, formatter, method(:twine_key_formatter))
+          f.puts "\t[#{key}]"
+          languages.keys.each do |lang|
+            f.puts "\t\t#{lang} = #{term.values[lang]}"
+          end
+          if pending_comment
+            f.puts "\t\tcomment = #{pending_comment}"
+            pending_comment = nil
+          end
+          f.puts ''
+        end
+      end
+    end
+
+    puts " > #{output_filename.yellow}"
+  end
+
+  private
+
+  def self.twine_key_formatter(key)
+    key.space_to_underscore.strip_tag.downcase
+  end
+end

data/localio.gemspec

@@ -1,35 +1,29 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'localio/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "localio"
-  spec.version = Localio::VERSION
-  spec.authors = ["Nacho Lopez"]
-  spec.email = ["nacho@nlopez.io"]
-  spec.description = %q{Automatic Localizable file generation for multiple platforms (Rails YAML, Android, Java Properties, iOS, JSON, .NET ResX)}
-  spec.summary = %q{Automatic Localizable file generation for multiple type of files, like Android string.xml, Xcode Localizable.strings, JSON files, Rails YAML files, Java properties, etc. reading from Google Drive and Excel spreadsheets as base.}
-  spec.homepage = "http://github.com/mrmans0n/localio"
-  spec.license = "MIT"
+  spec.name          = "localio"
+  spec.version       = Localio::VERSION
+  spec.authors       = ["Nacho Lopez"]
+  spec.email         = ["nacho@nlopez.io"]
+  spec.description   = %q{Automatic Localizable file generation for multiple platforms}
+  spec.summary       = %q{Generates Android, iOS, Rails, JSON, Java Properties, and .NET ResX localization files from spreadsheet sources.}
+  spec.homepage      = "https://github.com/mrmans0n/localio"
+  spec.license       = "MIT"
 
-  spec.files = `git ls-files`.split($/)
-  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files`.split("\n")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.executables << "localize"
+  spec.required_ruby_version = ">= 3.2"
 
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec",   "~> 3.0"
+  spec.add_development_dependency "rake",    "~> 13.0"
 
-  spec.required_ruby_version = ">= 1.9.2"
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-
-  spec.add_dependency "micro-optparse", "~> 1.2"
-  spec.add_dependency "google_drive", "~> 1.0"
-  spec.add_dependency "spreadsheet", "~> 1.0"
-  spec.add_dependency "simple_xlsx_reader", "~> 1.0"
-  spec.add_dependency "nokogiri", "~> 1.6"
+  spec.add_dependency "google_drive",        "~> 3.0"
+  spec.add_dependency "spreadsheet",         "~> 1.3"
+  spec.add_dependency "simple_xlsx_reader",  "~> 2.0"
+  spec.add_dependency "nokogiri",            "~> 1.16"
+  spec.add_dependency "csv",                 "~> 3.2"
 end

data/spec/fixtures/sample.csv

@@ -0,0 +1,11 @@
+Title Row,,,
+[key],*en,es,fr
+[comment],Section General,Section General,Section General
+app_name,My App,Mi Aplicación,Mon Application
+greeting,Hello %@ world,Hola %@ mundo,Bonjour %@ monde
+dots_test,Wait...,Espera...,Attendez...
+ampersand_test,Tom & Jerry,Tom & Jerry,Tom & Jerry
+[init-node],module,module,module
+nested_key,Module Key,Clave Módulo,Clé Module
+[end-node],end,end,end
+[end],,,

data/spec/localio/filter_spec.rb

@@ -0,0 +1,40 @@
+require 'localio/term'
+require 'localio/filter'
+
+RSpec.describe Filter do
+  let(:terms) do
+    ['app_name', 'app_title', 'settings_title', 'settings_back', '[comment]'].map { |kw| Term.new(kw) }
+  end
+
+  describe '.apply_filter' do
+    it 'returns all terms when no filters set' do
+      expect(Filter.apply_filter(terms, nil, nil)).to eq(terms)
+    end
+
+    context 'with only filter' do
+      it 'keeps terms matching the regex' do
+        result = Filter.apply_filter(terms, { keys: 'app_' }, nil)
+        expect(result.map(&:keyword)).to contain_exactly('app_name', 'app_title')
+      end
+
+      it 'returns empty array when nothing matches' do
+        expect(Filter.apply_filter(terms, { keys: 'nonexistent' }, nil)).to be_empty
+      end
+    end
+
+    context 'with except filter' do
+      it 'excludes terms matching the regex' do
+        result = Filter.apply_filter(terms, nil, { keys: 'settings_' })
+        expect(result.map(&:keyword)).not_to include('settings_title', 'settings_back')
+        expect(result.map(&:keyword)).to include('app_name', 'app_title')
+      end
+    end
+
+    context 'with both filters' do
+      it 'applies only first then except' do
+        result = Filter.apply_filter(terms, { keys: 'app_' }, { keys: 'title' })
+        expect(result.map(&:keyword)).to contain_exactly('app_name')
+      end
+    end
+  end
+end

data/spec/localio/formatter_spec.rb

@@ -0,0 +1,32 @@
+require 'localio/string_helper'
+require 'localio/formatter'
+
+RSpec.describe Formatter do
+  let(:smart_callback) { ->(key) { key.upcase } }
+
+  describe '.format' do
+    it ':smart delegates to callback' do
+      expect(Formatter.format('hello', :smart, smart_callback)).to eq('HELLO')
+    end
+
+    it ':none returns key unchanged' do
+      expect(Formatter.format('Hello World', :none, smart_callback)).to eq('Hello World')
+    end
+
+    it ':camel_case converts to CamelCase' do
+      expect(Formatter.format('hello world', :camel_case, smart_callback)).to eq('HelloWorld')
+    end
+
+    it ':camel_case strips single-letter bracket tags' do
+      expect(Formatter.format('[a]hello', :camel_case, smart_callback)).to eq('Hello')
+    end
+
+    it ':snake_case converts spaces to underscores and downcases' do
+      expect(Formatter.format('Hello World', :snake_case, smart_callback)).to eq('hello_world')
+    end
+
+    it 'raises ArgumentError for unknown formatter' do
+      expect { Formatter.format('key', :unknown, smart_callback) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/localio/processors/csv_processor_spec.rb

@@ -0,0 +1,89 @@
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/csv_processor'
+
+RSpec.describe CsvProcessor do
+  let(:fixture_path) { File.expand_path('../../../fixtures/sample.csv', __FILE__) }
+  let(:platform_options) { {} }
+  let(:options) { { path: fixture_path } }
+
+  describe '.load_localizables' do
+    subject(:result) { CsvProcessor.load_localizables(platform_options, options) }
+
+    it 'returns languages en, es, fr' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es', 'fr')
+    end
+
+    it 'sets en as default language (marked with *)' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'returns 8 terms between [key] and [end]' do
+      expect(result[:segments].count).to eq(8)
+    end
+
+    it 'parses term keywords correctly' do
+      keywords = result[:segments].map(&:keyword)
+      expect(keywords).to include('app_name', 'greeting', '[comment]', '[init-node]', '[end-node]')
+    end
+
+    it 'parses translations for each language' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+      expect(app_name.values['es']).to eq('Mi Aplicación')
+      expect(app_name.values['fr']).to eq('Mon Application')
+    end
+
+    it 'identifies comment rows' do
+      comment = result[:segments].find { |t| t.keyword == '[comment]' }
+      expect(comment.is_comment?).to be true
+    end
+
+    it 'raises ArgumentError when :path is missing' do
+      expect { CsvProcessor.load_localizables({}, {}) }
+        .to raise_error(ArgumentError, /:path attribute is missing/)
+    end
+
+    it 'raises IndexError when [key] marker is missing' do
+      Dir.mktmpdir do |tmpdir|
+        path = File.join(tmpdir, 'bad.csv')
+        File.write(path, "no,key,row\ndata,here,\n[end],,,\n")
+        expect { CsvProcessor.load_localizables({}, { path: path }) }
+          .to raise_error(IndexError, /Could not find any \[key\]/)
+      end
+    end
+
+    it 'raises IndexError when [end] marker is missing' do
+      Dir.mktmpdir do |tmpdir|
+        path = File.join(tmpdir, 'bad.csv')
+        File.write(path, "title,,,\n[key],*en,es,\ndata,val,val,\n")
+        expect { CsvProcessor.load_localizables({}, { path: path }) }
+          .to raise_error(IndexError, /Could not find any \[end\]/)
+      end
+    end
+
+    context 'with override_default option' do
+      let(:platform_options) { { override_default: 'es' } }
+
+      it 'uses the overridden default language' do
+        expect(result[:default_language]).to eq('es')
+      end
+    end
+
+    context 'with avoid_lang_downcase option' do
+      let(:tmpdir) { Dir.mktmpdir }
+      let(:options) do
+        path = File.join(tmpdir, 'upper.csv')
+        File.write(path, "Title,,,\n[key],*EN,ES,FR\napp_name,My App,Mi App,Mon App\n[end],,,\n")
+        { path: path }
+      end
+      let(:platform_options) { { avoid_lang_downcase: true } }
+
+      after { FileUtils.rm_rf(tmpdir) }
+
+      it 'preserves language case' do
+        expect(result[:languages].keys).to contain_exactly('EN', 'ES', 'FR')
+      end
+    end
+  end
+end

data/spec/localio/processors/google_drive_processor_spec.rb

@@ -0,0 +1,107 @@
+# google_drive transitively loads nokogiri.  Nokogiri is now built for arm64
+# and loads correctly, so we no longer need to stub it out.  We only stub
+# google_drive itself (which requires OAuth flow and network access) by:
+#   1. Defining minimal stub modules for GoogleDrive before anything tries to
+#      reference them.
+#   2. Pre-populating $LOADED_FEATURES with the google_drive gem paths so that
+#      every subsequent `require 'google_drive'` is treated as already loaded.
+# All runtime calls are intercepted by RSpec doubles.
+
+module GoogleDrive
+  module Session
+    def self.from_config(_config, _opts = {}); end
+    def self.from_service_account_key(_path, _scope = nil); end
+  end
+end
+
+begin
+  _gd_spec  = Gem::Specification.find_by_name('google_drive')
+  _gd_base  = File.join(_gd_spec.gem_dir, 'lib')
+  Dir["#{_gd_base}/**/*.rb"].sort.each do |f|
+    $LOADED_FEATURES << f unless $LOADED_FEATURES.include?(f)
+  end
+  ["#{_gd_base}/google_drive.rb"].each do |f|
+    $LOADED_FEATURES << f unless $LOADED_FEATURES.include?(f)
+  end
+end
+
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/google_drive_processor'
+
+RSpec.describe GoogleDriveProcessor do
+  let(:ws_data) do
+    {
+      [1, 1] => '[key]',    [1, 2] => '*en',  [1, 3] => 'es',
+      [2, 1] => 'app_name', [2, 2] => 'My App', [2, 3] => 'Mi Aplicación',
+      [3, 1] => 'greeting', [3, 2] => 'Hello',  [3, 3] => 'Hola',
+      [4, 1] => '[end]',    [4, 2] => '',        [4, 3] => '',
+    }
+  end
+
+  let(:worksheet) do
+    ws = double('worksheet')
+    allow(ws).to receive(:[]) { |row, col| ws_data[[row, col]].to_s }
+    allow(ws).to receive(:max_rows).and_return(4)
+    allow(ws).to receive(:max_cols).and_return(3)
+    ws
+  end
+
+  let(:spreadsheet_double) { double('spreadsheet', title: 'My Translations') }
+  let(:session_double) { double('session') }
+
+  before do
+    allow(spreadsheet_double).to receive(:worksheets).and_return([worksheet])
+    allow(session_double).to receive(:spreadsheets).and_return([spreadsheet_double])
+
+    # Mock the google_drive 3.x session creation method used by the processor.
+    # from_config is used for the OAuth2 client_id/client_secret flow.
+    allow(GoogleDrive::Session).to receive(:from_config).and_return(session_double)
+
+    # Allow File.file? to return false for the :client_token option in OAuth tests
+    # so the processor takes the from_config path (not the service-account path).
+    allow(File).to receive(:file?).and_call_original
+    allow(File).to receive(:file?).with('token').and_return(false)
+  end
+
+  let(:options) do
+    { spreadsheet: 'My Translations', client_id: 'id', client_secret: 'secret', client_token: 'token', sheet: 0 }
+  end
+
+  describe '.load_localizables' do
+    subject(:result) { GoogleDriveProcessor.load_localizables({}, options) }
+
+    it 'raises when :spreadsheet is missing' do
+      expect { GoogleDriveProcessor.load_localizables({}, { client_id: 'a', client_secret: 'b' }) }
+        .to raise_error(ArgumentError, /:spreadsheet required/)
+    end
+
+    it 'raises when :login is provided (deprecated)' do
+      expect { GoogleDriveProcessor.load_localizables({}, { spreadsheet: 'x', login: 'u', client_id: 'a', client_secret: 'b' }) }
+        .to raise_error(ArgumentError, /:login is deprecated/)
+    end
+
+    it 'raises when :client_id is missing' do
+      expect { GoogleDriveProcessor.load_localizables({}, { spreadsheet: 'x', client_secret: 'b' }) }
+        .to raise_error(ArgumentError, /:client_id required/)
+    end
+
+    it 'raises when :client_secret is missing' do
+      expect { GoogleDriveProcessor.load_localizables({}, { spreadsheet: 'x', client_id: 'a' }) }
+        .to raise_error(ArgumentError, /:client_secret required/)
+    end
+
+    it 'returns languages en and es' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es')
+    end
+
+    it 'sets en as default language' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'parses translations' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+    end
+  end
+end

data/spec/localio/processors/xls_processor_spec.rb

@@ -0,0 +1,65 @@
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/xls_processor'
+
+RSpec.describe XlsProcessor do
+  let(:data) do
+    {
+      [0, 0] => '[key]',    [0, 1] => '*en',  [0, 2] => 'es',             [0, 3] => 'fr',
+      [1, 0] => 'app_name', [1, 1] => 'My App', [1, 2] => 'Mi Aplicación', [1, 3] => 'Mon Application',
+      [2, 0] => 'greeting', [2, 1] => 'Hello',  [2, 2] => 'Hola',          [2, 3] => 'Bonjour',
+      [3, 0] => '[end]',    [3, 1] => '',       [3, 2] => '',              [3, 3] => '',
+    }
+  end
+
+  let(:worksheet) do
+    ws = double('worksheet')
+    allow(ws).to receive(:[]) { |row, col| data[[row, col]].to_s }
+    allow(ws).to receive(:row_count).and_return(3)
+    allow(ws).to receive(:column_count).and_return(3)
+    ws
+  end
+
+  let(:book_double) { double('book') }
+
+  before do
+    allow(Spreadsheet).to receive(:client_encoding=)
+    allow(Spreadsheet).to receive(:open).and_return(book_double)
+    allow(book_double).to receive(:worksheet).with(0).and_return(worksheet)
+  end
+
+  let(:options) { { path: 'fake.xls' } }
+  let(:platform_options) { {} }
+
+  describe '.load_localizables' do
+    subject(:result) { XlsProcessor.load_localizables(platform_options, options) }
+
+    it 'raises ArgumentError when :path is missing' do
+      expect { XlsProcessor.load_localizables({}, {}) }
+        .to raise_error(ArgumentError, /:path attribute is missing/)
+    end
+
+    it 'returns languages en, es, fr' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es', 'fr')
+    end
+
+    it 'sets en as default language' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'returns 2 terms' do
+      expect(result[:segments].count).to eq(2)
+    end
+
+    it 'parses translations correctly' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+    end
+
+    it 'raises when worksheet is nil' do
+      allow(book_double).to receive(:worksheet).and_return(nil)
+      expect { XlsProcessor.load_localizables({}, { path: 'fake.xls' }) }
+        .to raise_error(RuntimeError, /Unable to retrieve/)
+    end
+  end
+end

data/spec/localio/processors/xlsx_processor_spec.rb

@@ -0,0 +1,59 @@
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/xlsx_processor'
+
+RSpec.describe XlsxProcessor do
+  let(:rows) do
+    [
+      ['Title', nil, nil, nil],
+      ['[key]', '*en', 'es', 'fr'],
+      ['[comment]', 'Section General', 'Section General', 'Section General'],
+      ['app_name', 'My App', 'Mi Aplicación', 'Mon Application'],
+      ['greeting', 'Hello', 'Hola', 'Bonjour'],
+      ['[end]', nil, nil, nil],
+    ]
+  end
+
+  let(:sheet_double) { double('sheet', rows: rows) }
+  let(:book_double) { double('book', sheets: [sheet_double]) }
+
+  before { allow(SimpleXlsxReader).to receive(:open).and_return(book_double) }
+
+  let(:options) { { path: 'fake.xlsx', sheet: 0 } }
+  let(:platform_options) { {} }
+
+  describe '.load_localizables' do
+    subject(:result) { XlsxProcessor.load_localizables(platform_options, options) }
+
+    it 'raises ArgumentError when :path is missing' do
+      expect { XlsxProcessor.load_localizables({}, {}) }
+        .to raise_error(ArgumentError, /:path attribute is missing/)
+    end
+
+    it 'returns languages en, es, fr' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es', 'fr')
+    end
+
+    it 'sets en as default language' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'returns 3 terms' do
+      expect(result[:segments].count).to eq(3)
+    end
+
+    it 'parses translations correctly' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+      expect(app_name.values['es']).to eq('Mi Aplicación')
+    end
+
+    it 'raises when sheet is nil' do
+      named_book = double('book', sheets: [])
+      allow(SimpleXlsxReader).to receive(:open).and_return(named_book)
+      allow(named_book).to receive(:sheets).and_return([])
+      expect { XlsxProcessor.load_localizables({}, { path: 'fake.xlsx', sheet: 'Missing' }) }
+        .to raise_error(RuntimeError, /Unable to retrieve/)
+    end
+  end
+end

data/spec/localio/segment_spec.rb

@@ -0,0 +1,27 @@
+require 'localio/string_helper'
+require 'localio/segment'
+
+RSpec.describe Segment do
+  subject(:segment) { Segment.new('app_name', 'My App', 'en') }
+
+  it 'stores key, translation, and language' do
+    expect(segment.key).to eq('app_name')
+    expect(segment.translation).to eq('My App')
+    expect(segment.language).to eq('en')
+  end
+
+  it 'processes translation through replace_escaped' do
+    seg = Segment.new('key', 'hello`+world', 'en')
+    expect(seg.translation).to eq('hello+world')
+  end
+
+  describe '#is_comment?' do
+    it 'returns true when key is nil' do
+      segment.key = nil
+      expect(segment.is_comment?).to be true
+    end
+    it 'returns false when key is set' do
+      expect(segment.is_comment?).to be false
+    end
+  end
+end

data/spec/localio/segments_list_holder_spec.rb

@@ -0,0 +1,22 @@
+require 'localio/segments_list_holder'
+
+RSpec.describe SegmentsListHolder do
+  subject(:holder) { SegmentsListHolder.new('en') }
+
+  it { expect(holder.language).to eq('en') }
+  it { expect(holder.segments).to be_empty }
+
+  describe '#get_binding' do
+    it 'returns a Binding' do
+      expect(holder.get_binding).to be_a(Binding)
+    end
+
+    it 'exposes @language in the binding' do
+      expect(eval('@language', holder.get_binding)).to eq('en')
+    end
+
+    it 'exposes @segments in the binding' do
+      expect(eval('@segments', holder.get_binding)).to eq([])
+    end
+  end
+end