skala 0.3.0 → 1.1.0

data/lib/skala/i18n.rb

@@ -1,46 +0,0 @@
-require "active_support"
-require "active_support/core_ext"
-require "mighty_tap"
-require "yaml"
-require_relative "../skala"
-
-module Skala::I18n
-  def self.included(klass)
-    klass.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    def load_locales_from_directory(path)
-      Dir.glob("#{File.expand_path(path)}/*.yml").inject({}) do |_locales, _filename|
-        _locales.mtap(:deep_merge!, YAML.load_file(_filename))
-      end
-    end
-
-    # override this to provide locales
-    def locales
-      {}
-    end
-
-    def translate(key, options = {})
-      raise "Destination locale missing!" if options[:locale].nil?
-     
-      fully_qualified_key = "#{options[:locale]}.#{key}"
-      keys_path = fully_qualified_key.split(".")
-      
-      translated_key = keys_path.inject(locales) do |hash, hash_key|
-        unless hash.nil?
-          hash[hash_key.to_s] || hash[hash_key.to_sym]
-        end
-      end || keys_path.last
-
-      translated_key.gsub(/%{[^}]+}+/) do |match|
-        interpolation_key = match.gsub(/(\A%{)|(}\Z)/, "")
-        options[interpolation_key.to_s] || options[interpolation_key.to_sym] || match
-      end
-    end
-  end
-
-  def translate(*args)
-    self.class.translate(*args)
-  end
-end

data/lib/skala/transformation.rb

@@ -1,54 +0,0 @@
-require_relative "../skala"
-
-class Skala::Transformation
-  require_relative "./transformation/step"
-
-  #
-  # class methods
-  #
-  class << self
-    attr_accessor :steps
-  end
-
-  # since a transformation can have many steps, writing a "require" for each is tedious
-  def self.require_directory(directory)
-    Dir.glob("#{File.expand_path(directory)}/*.rb").each do |filename|
-      require filename
-    end
-  end
-
-  # convenience wrapper for @steps setter to enhance readability
-  def self.sequence(value)
-    self.steps = value
-  end
-
-  #
-  # instance methods
-  #
-  attr_accessor :source
-  attr_accessor :target
-
-  def apply(options = {})
-    if (@source = options[:source] ||= options[:to]).nil?
-      raise ArgumentError, "No source given to apply transformation to!"
-    end
-
-    @target = options[:target]
-
-    self.class.steps.flatten.each do |step|
-      break if @__aborted
-
-      if step.is_a?(Class)
-        step.new(self).call
-      else
-        step.call(self)
-      end
-    end
-
-    return @target
-  end
-
-  def abort!
-    @__aborted = true
-  end
-end

data/lib/skala/transformation/step.rb

@@ -1,24 +0,0 @@
-require_relative "../transformation"
-
-class Skala::Transformation::Step
-  attr_accessor :transformation
-
-  def initialize(transformation)
-    @transformation = transformation
-  end
-
-  #
-  # Each step has transparent access to all methods of it's transformation
-  #
-  def method_missing(method_name, *args, &block)
-    if @transformation.respond_to?(method_name)
-      @transformation.send(method_name, *args, &block)
-    else
-      super
-    end
-  end
-
-  def respond_to_missing?(method_name, include_private = false)
-    @transformation.respond_to?(method_name) || super
-  end
-end

data/spec/assets/locales/de.yml

@@ -1,14 +0,0 @@
-de:
-  field_names:
-    _all: Alle Felder
-    _score: Relevanz
-    created: Erscheinungsjahr
-    creator: Autor/Herausgeber
-    identifier: Identifikator
-    subject: Schlagwort
-    title: Titel
-
-  records:
-    items:
-      loan_status:
-        expected: Erwartet zum %{expected_date}

data/spec/assets/locales/en.yml

@@ -1,9 +0,0 @@
-en:
-  field_names:
-    _all: All fields
-    _score: Score
-    created: Created
-    creator: Creator
-    identifier: Identifier
-    subject: Subject
-    title: Title

data/spec/assets/transformation/some_class.rb

@@ -1,2 +0,0 @@
-class SomeClass
-end

data/spec/skala/adapter/operation_spec.rb

@@ -1,19 +0,0 @@
-describe Skala::Adapter::Operation do
-  let(:adapter) do
-    {
-      some: "adapter"
-    }
-  end
-
-  context "if initialized with a adapter" do
-    let(:operation) do
-      described_class.new(adapter)
-    end
-
-    describe "#adapter" do
-      it "returns the adapter the operation was initialized with" do
-        expect(operation.adapter).to eq(adapter) 
-      end
-    end
-  end
-end

data/spec/skala/adapter_spec.rb

@@ -1,2 +0,0 @@
-describe Skala::Adapter do
-end

data/spec/skala/i18n_spec.rb

@@ -1,95 +0,0 @@
-describe Skala::I18n do
-  let(:class_with_i18n_included) do
-    Class.new.tap do |_klass|
-      _klass.send(:include, described_class)
-    end
-  end
-
-  context "when included into a class" do
-    it "defines a class method #load_locales_from_directory" do
-      expect(class_with_i18n_included).to respond_to(:load_locales_from_directory)
-    end
-
-    it "defines a class method #locales" do
-      expect(class_with_i18n_included).to respond_to(:locales)
-    end
-
-    it "defines a class method #translate" do
-      expect(class_with_i18n_included).to respond_to(:translate)
-    end
-
-    it "defines an instance method .translate" do
-      expect(class_with_i18n_included.new).to respond_to(:translate)
-    end
-  end
- 
-  describe "#load_locales_from_directory" do
-    it "loads all yaml encoded locales from a directory" do
-      loaded_locales =
-      class_with_i18n_included.load_locales_from_directory(
-        File.expand_path("#{File.dirname(__FILE__)}/../assets/locales")
-      )
-
-      expect(loaded_locales).not_to be_empty
-    end
-  end
-  
-  describe "#translate" do
-    context "if the class defines .locales" do
-      let(:class_with_i18n_included_and_locales) do
-        Class.new(class_with_i18n_included).tap do |_klass|
-          def _klass.locales
-            load_locales_from_directory(
-              File.expand_path("#{File.dirname(__FILE__)}/../assets/locales")
-            )
-          end
-        end
-      end
-
-      let(:object) do
-        class_with_i18n_included_and_locales.new
-      end
-
-      it "translates the given key into the language specified by the locale option" do
-        translated_key_de = object.translate("field_names.creator", locale: :de)
-        translated_key_en = object.translate("field_names.creator", locale: :en)
-        
-        expected_translation_de = object.class.locales["de"]["field_names"]["creator"]
-        expected_translation_en = object.class.locales["en"]["field_names"]["creator"]
-
-        expect(translated_key_de).to eq(expected_translation_de)
-        expect(translated_key_en).to eq(expected_translation_en)
-      end
-      
-      it "supports rails style interpolation" do
-        expected_date = "1. Januar 2015"
-        translated_key = object.translate("records.items.loan_status.expected", locale: :de, expected_date: expected_date)
-        expected_translation = object.class.locales["de"]["records"]["items"]["loan_status"]["expected"].gsub("%{expected_date}", expected_date)
-
-        expect(translated_key).to eq(expected_translation)
-      end
-      
-      context "when there is no translation" do
-        it "returns the last key path" do
-          expect(object.translate("foo.bar.muff", locale: :en)).to eq("muff")
-        end
-      end
-
-      context "when no locale option is given" do
-        it "raises an exception" do
-          expect { object.translate("field_names.creator") }.to raise_error
-        end
-      end
-    end
-
-    context "if the class does not define .locales" do
-      let(:object) do
-        class_with_i18n_included.new
-      end      
-
-      it "returns the last key path" do
-        expect(object.translate("foo.bar.muff", locale: :en)).to eq("muff")
-      end
-    end
-  end
-end

data/spec/skala/transformation/step_spec.rb

@@ -1,36 +0,0 @@
-describe Skala::Transformation::Step do
-  context "when initialized with a transformation" do
-    let(:transformation) do
-      Class.new(Skala::Transformation) do
-        def some_transformation_method
-          true
-        end
-      end.new
-    end
-
-    let(:step) do
-      described_class.new(transformation)
-    end
-
-    describe "#transformation" do
-      it "allows access to the transformation" do
-        expect(step.transformation).to be(transformation)
-      end
-    end
-
-    context "if a unknown method is called" do
-      context "if the transformation has a matching method" do
-        it "calls the method on the transformation" do
-          expect(step).to respond_to(:some_transformation_method)
-          expect(step.some_transformation_method).to eq(transformation.some_transformation_method)
-        end
-      end
-
-      context "if the transformation has no matching method" do
-        it "raises an error" do
-          expect { step.some_unknown_method }.to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/skala/transformation_spec.rb

@@ -1,89 +0,0 @@
-describe Skala::Transformation do
-  describe ".require_directory" do
-    it "requires all *.rb files in the given directory" do
-      described_class.require_directory "#{File.dirname(__FILE__)}/../assets/transformation"
-      expect(defined?(SomeClass)).to eq("constant")
-    end
-  end
-
-  describe "#sequence" do
-    let(:steps_array) do
-      [ -> { } ]
-    end
-
-    let(:transformation) do
-      steps = steps_array
-
-      Class.new(described_class) do
-        sequence steps
-      end
-    end
-
-    it "is a wrapper for the steps setter" do
-      expect(transformation.steps).to be(steps_array)
-    end
-  end
-
-  describe "#abort!" do
-    let(:transformation) do
-      Class.new(described_class) do
-        def abort_execution?
-          !!@abort_execution
-        end
-
-        def initialize(abort_execution = true)
-          @abort_execution = abort_execution
-        end
-
-        sequence [
-          -> (transformation) do
-            transformation.target = "first_steps_output"
-            transformation.abort! if transformation.abort_execution?
-          end,
-          -> (transformation) do
-            transformation.target = "second_steps_output"
-          end
-        ]
-      end
-    end
-
-    it "aborts the execution of the steps sequence" do
-      expect(transformation.new.apply to: {}).to eq("first_steps_output")
-      expect(transformation.new(false).apply to: {}).to eq("second_steps_output")
-    end
-  end
-
-  describe "#apply" do
-    let(:transformation) do
-      step_class = Class.new(described_class::Step) do
-        def call
-          transformation.target = source.dup
-        end
-      end
-
-      step_lambda = -> (transformation) do
-        transformation.target.upcase!
-      end
-
-      Class.new(described_class) do
-        sequence [
-          step_class,
-          step_lambda
-        ]
-      end.new
-    end
-
-    context "if no :source or :to option is given" do
-      it "raises an error" do
-        expect { transformation.apply }.to raise_error(ArgumentError)
-      end
-    end
-
-    it "applies the transformation" do
-      some_string = "foo"
-
-      expect(transformation.apply(to: some_string)).to eq(some_string.upcase)
-      expect(some_string).to eq("foo")
-    end
-  end
-end

data/spec/skala_spec.rb

@@ -1,2 +0,0 @@
-describe Skala do
-end