rosetta-stone 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3cf674dc5b340ddd9571dd573754c8053b9bb979b53cb29724c0614f3a97ca5
-  data.tar.gz: 9ffb03bc8efa51760fa3f9ca970fc9dd99c5041360dae61dd1ad35382bc903f9
+  metadata.gz: 6f49ad30a0b19d92be9bca2d6b43eca56f1843fe9b594d9c46c1401113304c15
+  data.tar.gz: 5989f92c630e155ea5da9a5191c6a06e5e41ac2f8854d347372f611b814a0b68
 SHA512:
-  metadata.gz: 0c9d3c191c137f481b690e91803b8e8ea80a2a47c298c66c3f0f184de06f5e91c5c9e1d9731dfd25e9e129e7c7caa40ceb25202260e0d6992ebcbbcf2d17c633
-  data.tar.gz: e474a60fe27c7c91e78282b4598d6de4e739f267e64799b92f2a50118385c3d06b01decfcbe5a143164062f901e2a791b7fed9833cf548fe32f04b3fb30b7ca0
+  metadata.gz: ef07a8fbf976977caff7b8de46ff30df4ff500df9784bda69fb81e146d03123f7208434f5eddf8cacb57663d0113f5a352cd3ded94664ac09cd5f36eee4a8914
+  data.tar.gz: 12c85f29aebe211372dc362c221bc6f82e0ff8f64524060c2fb679e9ac7185893b0b2e9421e4f4a9dae7331b1095d71c2b5b8809d574d1ffd8531aa059475d74

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rosetta-stone (0.1.0)
+    rosetta-stone (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -7,7 +7,7 @@ A lightweight format-to-format translator.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'rosetta'
+gem 'rosetta-stone'
 ```
 
 And then execute:
@@ -16,7 +16,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install rosetta
+    $ gem install rosetta-stone
 
 ## Usage
 
@@ -64,7 +64,7 @@ Rosetta::Translation.new(deserializer, serializer).call("olleh") # => HELLO
 When given `Symbol`s instead, they will try to lookup the registered serializers
 and deserializers to find a match to use with the input.
 By default, the only ones supplied with the gem are a JSON deserializer and a
-CSV serializer.
+CSV serializer. (`Rosetta::Deserializers::JSON` and `Rosetta::Serializers::CSV`).
 See *Registering a Serializer / Deserializer* for more info on how to add your own.
 
 You can also register `Translator`s, which are pipes connecting to specific
@@ -76,7 +76,7 @@ See *Registering a Translator* for more info on how to use them.
 You can register a new serializer or deserializer by calling the `register`
 methods of respectively `Rosetta::Serializers` or `Rosetta::Deserializers`.
 The method takes the Symbol that's going to be used as shorthand for it as first
-parameter and the callable object you want to use as second.
+parameter and either a callable object or a block for the serializer/deserializer.
 
 Example:
 ```ruby
@@ -87,6 +87,11 @@ Rosetta::Deserializers.register(:mirror, deserializer)
 Rosetta::Serializers.register(:BIG, serializer)
 
 Rosetta.translate(from: :mirror, to: :big, "em ti si") # => "IS IT ME"
+
+# Alternative
+
+Rosetta::Deserializers.register(:BIG)    { |input| input.upcase  }
+Rosetta::Deserializers.register(:mirror) { |input| input.reverse }
 ```
 
 Whatever the Deserializer returns will be fed to the Serializer when

data/lib/rosetta/deserializers.rb

@@ -1,54 +1,23 @@
 require 'rosetta/exceptions'
 
 module Rosetta
-  class Deserializers
+  module Deserializers
     @registered = {}
 
-    def self.[](key)
-      @registered[key]
-    end
-
-    def self.register(name, deserializer)
-      raise ExistingDeserializerError, <<-ERROR.strip if @registered.key? name
-        Deserializer #{name} is already registered.
-      ERROR
-      @registered[name] = deserializer
-    end
-
-    class Base
-      attr_reader :input
-
-      class << self
-        def inherited(new_serializer)
-          key = new_serializer.name.match(/^(.*?)(Deserializer)?$/)[1]
-          key = key.split("::").last
-          #NOTE: Similar to Rails's #underscore
-          #TODO: Extract in refinement?
-          key = key.scan(/[A-Z]+[a-z]*/).join('_').downcase.to_sym
-          Deserializers.register(key, new_serializer)
-        end
+    class << self
+      attr_reader :registered
 
-        def call(input)
-          new(input).call
-        end
-        alias_method :deserialize, :call
-
-        def to_proc
-          proc { |*args, &block| self.call(*args, &block) }
-        end
-      end
-
-      def initialize(input)
-        @input = input.dup.freeze
+      def [](key)
+        registered[key]
       end
 
-      def call
-        raise NotImplementedError
-      end
-      alias_method :deserialize, :call
+      def register(name, deserializer, &block)
+        raise ExistingDeserializerError, <<-ERROR.strip if @registered.key? name
+          Deserializer #{name} is already registered.
+        ERROR
 
-      def to_proc
-        proc { |*args, &block| self.call(*args, &block) }
+        raise ArgumentError, "Can't take both deserializer object and block." if deserializer && block
+        @registered[name] = deserializer
       end
     end
   end

data/lib/rosetta/deserializers/base.rb

@@ -0,0 +1,43 @@
+require 'rosetta/deserializers'
+require 'rosetta/exceptions'
+
+module Rosetta
+  module Deserializers
+    class Base
+      attr_reader :input
+
+      class << self
+        def inherited(new_serializer)
+          key = new_serializer.name.match(/^(.*?)(Deserializer)?$/)[1]
+          key = key.split("::").last
+          #NOTE: Similar to Rails's #underscore
+          #TODO: Extract in refinement?
+          key = key.scan(/[A-Z]+[a-z]*/).join('_').downcase.to_sym
+          Deserializers.register(key, new_serializer)
+        end
+
+        def call(input)
+          new(input).call
+        end
+        alias_method :deserialize, :call
+
+        def to_proc
+          proc { |*args, &block| self.call(*args, &block) }
+        end
+      end
+
+      def initialize(input)
+        @input = input.dup.freeze
+      end
+
+      def call
+        raise NotImplementedError
+      end
+      alias_method :deserialize, :call
+
+      def to_proc
+        proc { |*args, &block| self.call(*args, &block) }
+      end
+    end
+  end
+end

data/lib/rosetta/deserializers/json.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+require 'rosetta/element'
+require 'rosetta/exceptions'
+require 'rosetta/deserializers/base'
+
+module Rosetta
+  module Deserializers
+    class JSON < Base
+      def call
+        validate_input!
+        input.map { |obj| Element.new(obj) }
+      end
+
+      private
+
+        def validate_input!
+          raise DeserializationError, <<-ERROR.strip unless parsed_input = valid_json(@input)
+            JSON input is invalid
+          ERROR
+          raise DeserializationError, <<-ERROR.strip unless parsed_input.is_a? Array
+            JSON input must be an array
+          ERROR
+          raise DeserializationError, <<-ERROR.strip unless parsed_input.all? { |o| o.is_a? Hash }
+            JSON input must contain objects
+          ERROR
+
+          @input = parsed_input.freeze
+        end
+
+        #HACK: Feels dirty but there's no JSON soft-parsing in ruby's json lib
+        def valid_json(json)
+          JSON(json)
+        #NOTE: Rescuing TypeError too in case json is not a String
+        rescue ::JSON::ParserError, TypeError
+          nil
+        end
+    end
+  end
+end

data/lib/rosetta/serializers.rb

@@ -1,55 +1,23 @@
 require 'rosetta/exceptions'
 
 module Rosetta
-  class Serializers
+  module Serializers
     @registered = {}
 
-    def self.[](key)
-      @registered[key]
-    end
-
-    def self.register(name, serializer)
-      raise ExistingSerializerError, <<-ERROR.strip if @registered.key? name
-        Serializer #{name} is already registered.
-      ERROR
-      @registered[name] = serializer
-    end
-
-    class Base
-      attr_reader :elements
-
-      class << self
-        def inherited(new_serializer)
-          key = new_serializer.name.match(/^(.*?)(Serializer)?$/)[1]
-          key = key.split("::").last
-          #NOTE: Similar to Rails's #underscore
-          #TODO: Extract in refinement?
-          key = key.scan(/[A-Z]+[a-z]*/).join('_').downcase.to_sym
-          Serializers.register(key, new_serializer)
-        end
+    class << self
+      attr_reader :registered
 
-        def call(elements)
-          new(elements).call
-        end
-        alias_method :serialize, :call
-
-        def to_proc
-          proc { |*args, &block| self.call(*args, &block) }
-        end
-      end
-
-      def initialize(elements)
-        @elements = elements.dup.freeze
-        validate_input!
+      def [](key)
+        @registered[key]
       end
 
-      def call
-        raise NotImplementedError
-      end
-      alias_method :serialize, :call
+      def register(name, serializer, &block)
+        raise ExistingSerializerError, <<-ERROR.strip if @registered.key? name
+          Serializer #{name} is already registered.
+        ERROR
 
-      def to_proc
-        proc { |*args, &block| self.call(*args, &block) }
+        raise ArgumentError, "Can't take both serializer object and block." if serializer && block
+        @registered[name] = serializer
       end
     end
   end

data/lib/rosetta/serializers/base.rb

@@ -0,0 +1,44 @@
+require 'rosetta/serializers'
+require 'rosetta/exceptions'
+
+module Rosetta
+  module Serializers
+    class Base
+      attr_reader :elements
+
+      class << self
+        def inherited(new_serializer)
+          key = new_serializer.name.match(/^(.*?)(Serializer)?$/)[1]
+          key = key.split("::").last
+          #NOTE: Similar to Rails's #underscore
+          #TODO: Extract in refinement?
+          key = key.scan(/[A-Z]+[a-z]*/).join('_').downcase.to_sym
+          Serializers.register(key, new_serializer)
+        end
+
+        def call(elements)
+          new(elements).call
+        end
+        alias_method :serialize, :call
+
+        def to_proc
+          proc { |*args, &block| self.call(*args, &block) }
+        end
+      end
+
+      def initialize(elements)
+        @elements = elements.dup.freeze
+        validate_input!
+      end
+
+      def call
+        raise NotImplementedError
+      end
+      alias_method :serialize, :call
+
+      def to_proc
+        proc { |*args, &block| self.call(*args, &block) }
+      end
+    end
+  end
+end

data/lib/rosetta/serializers/csv.rb

@@ -0,0 +1,43 @@
+require 'csv'
+
+require 'rosetta/exceptions'
+require 'rosetta/serializers/base'
+
+module Rosetta
+  module Serializers
+    class CSV < Base
+      def call
+        ::CSV.generate do |csv|
+          csv << headers
+          elements.each do |element|
+            csv << headers.map { |header| serialize_value(element[header]) }
+          end
+        end
+      end
+
+      def headers
+        head, *_ = elements.map(&:properties).uniq
+        head
+      end
+
+      def validate_input!
+        _, *others = elements.map(&:properties).uniq
+
+        raise SerializationError, <<-ERROR.strip unless others.none?
+          All objects need to share their structure to be serialized to CSV.
+        ERROR
+      end
+
+      private
+
+        def serialize_value(value)
+          case value
+          when Array
+            value.join(',')
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/lib/rosetta/translation.rb

@@ -3,21 +3,24 @@ require 'rosetta/exceptions'
 module Rosetta
   class Translation
     @registered = {}
-
     attr_reader :serializer, :deserializer, :translator
     alias_method :translator?, :translator
 
-    def self.register(source, destination, callable = nil, &block)
-      raise ExistingTranslatorError, <<-ERROR.strip if @registered.key? name
-        There already is a translator from #{source} to #{destination}.
-      ERROR
+    class << self
+      attr_reader :registered
 
-      raise ArgumentError, "Can't take both callabel object and block." if callable && block
-      @registered[source => destination] = callable || block
-    end
+      def [](key)
+        @registered[key]
+      end
 
-    def self.[](key)
-      @registered[key]
+      def register(source, destination, callable = nil, &block)
+        raise ExistingTranslatorError, <<-ERROR.strip if @registered.key? name
+          There already is a translator from #{source} to #{destination}.
+        ERROR
+
+        raise ArgumentError, "Can't take both callable object and block." if callable && block
+        @registered[source => destination] = callable || block
+      end
     end
 
     def initialize(deserializer, serializer)

data/lib/rosetta/version.rb

@@ -1,3 +1,3 @@
 module Rosetta
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rosetta-stone
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jérémie Bonal
@@ -85,12 +85,14 @@ files:
 - bin/console
 - bin/setup
 - lib/rosetta.rb
-- lib/rosetta/csv_serializer.rb
 - lib/rosetta/deserializers.rb
+- lib/rosetta/deserializers/base.rb
+- lib/rosetta/deserializers/json.rb
 - lib/rosetta/element.rb
 - lib/rosetta/exceptions.rb
-- lib/rosetta/json_deserializer.rb
 - lib/rosetta/serializers.rb
+- lib/rosetta/serializers/base.rb
+- lib/rosetta/serializers/csv.rb
 - lib/rosetta/translation.rb
 - lib/rosetta/version.rb
 - rosetta.gemspec

data/lib/rosetta/csv_serializer.rb

@@ -1,41 +0,0 @@
-require 'csv'
-
-require 'rosetta/exceptions'
-require 'rosetta/serializers'
-
-module Rosetta
-  class CSVSerializer < Serializers::Base
-    def call
-      CSV.generate do |csv|
-        csv << headers
-        elements.each do |element|
-          csv << headers.map { |header| serialize_value(element[header]) }
-        end
-      end
-    end
-
-    def headers
-      head, *_ = elements.map(&:properties).uniq
-      head
-    end
-
-    def validate_input!
-      _, *others = elements.map(&:properties).uniq
-
-      raise SerializationError, <<-ERROR.strip unless others.none?
-        All objects need to share their structure to be serialized to CSV.
-      ERROR
-    end
-
-    private
-
-      def serialize_value(value)
-        case value
-        when Array
-          value.join(',')
-        else
-          value
-        end
-      end
-  end
-end

data/lib/rosetta/json_deserializer.rb

@@ -1,38 +0,0 @@
-require 'json'
-
-require 'rosetta/element'
-require 'rosetta/exceptions'
-require 'rosetta/deserializers'
-
-module Rosetta
-  class JSONDeserializer < Deserializers::Base
-    def call
-      validate_input!
-      input.map { |obj| Element.new(obj) }
-    end
-
-    private
-
-      def validate_input!
-        raise DeserializationError, <<-ERROR.strip unless parsed_input = valid_json(@input)
-          JSON input is invalid
-        ERROR
-        raise DeserializationError, <<-ERROR.strip unless parsed_input.is_a? Array
-          JSON input must be an array
-        ERROR
-        raise DeserializationError, <<-ERROR.strip unless parsed_input.all? { |o| o.is_a? Hash }
-          JSON input must contain objects
-        ERROR
-
-        @input = parsed_input.freeze
-      end
-
-      #HACK: Feels dirty but there's no JSON soft-parsing in ruby's json lib
-      def valid_json(json)
-        JSON(json)
-      #NOTE: Rescuing TypeError too in case json is not a String
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-  end
-end