metacrunch 2.2.3 → 3.0.0

data/lib/metacrunch/snr.rb

@@ -1,117 +0,0 @@
-module Metacrunch
-  #
-  # A SNR object (Simple Normalized Record) is a simple data structure
-  # that you can use as a target resource when performing data normalization routines.
-  # A DNSR record consists of unique sections. A section is unique identified by it's
-  # name. Each section can hold many fields that store the actual values.
-  #
-  # A SNR object can be transformed into XML or JSON to allow easy integration into
-  # existing tools and workflows.
-  #
-  # For example: If you normalize MAB XML data for use in a search engine you can
-  # use a SNR object to store your normalized values.
-  #
-  class SNR
-    require_relative "./snr/section"
-    require_relative "./snr/field"
-
-    # ------------------------------------------------------------------------------
-    # Common API
-    # ------------------------------------------------------------------------------
-
-    #
-    # Adds a field with a value to a section. If the section with the given name
-    # doesn't exists it will be created.
-    #
-    # @param [String] section_name
-    # @param [String] field_name
-    # @param [#to_s] value
-    #
-    def add(section_name, field_name, value)
-      section = self.section(section_name) || Section.new(section_name)
-      section.add(field_name, value)
-      add_section(section)
-    end
-
-    #
-    # Returns field values for a given path.
-    #
-    # @param [String] path A path to the fields seperated by /. E.g. section/field
-    # @return [Array<*>]
-    #
-    def values(path)
-      section_name, field_name = path.split("/")
-      section = self.section(section_name)
-      if section && field_name
-        section.fields(field_name).map{|field| field.value}
-      else
-        []
-      end
-    end
-
-    # ------------------------------------------------------------------------------
-    # Sections
-    # ------------------------------------------------------------------------------
-
-    #
-    # @return [Hash{String => Metacrunch::SNR::Section}]
-    # @private
-    #
-    def sections_struct
-      @sections_struct ||= {}
-    end
-    private :sections_struct
-
-    #
-    # Return all sections.
-    #
-    # @return [Array<Metacrunch::SNR::Section>]
-    #
-    def sections
-      sections_struct.values
-    end
-
-    #
-    # Get section by name.
-    #
-    # @param  [String] name Name of the section
-    # @return [Metacrunch::SNR::Section, nil] section by name or nil if a section
-    #   with the given name doesn't exists.
-    #
-    def section(name)
-      sections_struct[name]
-    end
-
-    #
-    # Adds / replaces a section. The name of the section is used as a unique identifier.
-    # Therefore if you add a section with a name that already exists, the new section
-    # will override the existing one.
-    #
-    # @param [Metacrunch::SNR::Section] section
-    # @return [Metacrunch::SNR::Section]
-    #
-    def add_section(section)
-      sections_struct[section.name] = section
-    end
-
-    # ------------------------------------------------------------------------------
-    # Serialization
-    # ------------------------------------------------------------------------------
-
-    #
-    # Transforms the SNR into XML.
-    #
-    # @return [String] The SNR as XML string.
-    #
-    def to_xml
-      builder = Builder::XmlMarkup.new(indent: 2)
-      builder.instruct!(:xml, :encoding => "UTF-8")
-      builder.snr do
-        sections.each do |_section|
-          _section.to_xml(builder)
-        end
-      end
-    end
-
-  end
-end

data/lib/metacrunch/tar_writer.rb

@@ -1,26 +0,0 @@
-require "rubygems/package"
-
-module Metacrunch
-  class TarWriter < FileWriter
-
-    def write(data, options = {})
-      raise ArgumentError, "Missing option 'filename'" if options[:filename].blank?
-
-      io.add_file_simple(options[:filename], 0644, data.bytesize) do |_io|
-        if block_given?
-          yield(_io)
-        else
-          _io.write(data)
-        end
-      end
-    end
-
-  private
-
-    def io
-      @io     ||= super
-      @tar_io ||= Gem::Package::TarWriter.new(@io)
-    end
-
-  end
-end

data/lib/metacrunch/transformator/transformation/step.rb

@@ -1,45 +0,0 @@
-require_relative "../transformation"
-
-class Metacrunch::Transformator::Transformation::Step
-  attr_accessor :transformation
-
-  def initialize(transformation = nil, options = {})
-    if transformation.is_a?(Hash)
-      options = transformation
-      transformation = nil
-    end
-
-    if transformation
-      @transformation = transformation
-    else
-      @transformation = Struct.new(:source, :target).new.tap do |_struct|
-        _struct.source = options[:source]
-        _struct.target = options[:target]
-      end
-    end
-  end
-
-  def call
-  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
-
-  # avoid method_missing penalty for the most used transformation methods
-  def source;         @transformation.source;         end
-  def source=(value); @transformation.source=(value); end
-  def target;         @transformation.target;         end
-  def target=(value); @transformation.target=(value); end
-end

data/lib/metacrunch/transformator/transformation.rb

@@ -1,48 +0,0 @@
-require_relative "../transformator"
-
-class Metacrunch::Transformator::Transformation
-  require_relative "./transformation/step"
-
-  attr_accessor :source
-  attr_accessor :target
-
-  class << self
-    def steps(value = nil)
-      unless value
-        @steps
-      else
-        @steps = value
-      end
-    end
-    alias_method :sequence, :steps
-  end
-
-  def self.call(*args)
-    new.call(*args)
-  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
-
-  def initialize
-    # steps are instanced once, which means that instance variables retain
-    @steps = self.class.steps.flatten.map do |_step|
-      _step.is_a?(Class) ? _step.new(self) : _step
-    end
-  end
-
-  def call(source, options = {})
-    @source = source
-    @target = options[:target]
-
-    @steps.each do |_step|
-      _step.is_a?(Proc) ? instance_exec(&_step) : _step.call
-    end
-
-    return @target
-  end
-end

data/lib/metacrunch/transformator.rb

@@ -1,5 +0,0 @@
-require_relative "../metacrunch"
-
-module Metacrunch::Transformator
-  require_relative "./transformator/transformation"
-end

data/lib/metacrunch/transformer/helper.rb

@@ -1,29 +0,0 @@
-require_relative "../transformer"
-
-module Metacrunch
-  class Transformer
-    class Helper
-
-      def initialize(transformer)
-        @transformer = transformer
-      end
-
-      def transformer
-        @transformer
-      end
-
-      def source
-        transformer.source
-      end
-
-      def target
-        transformer.target
-      end
-
-      def options
-        transformer.options
-      end
-
-    end
-  end
-end

data/lib/metacrunch/transformer/step.rb

@@ -1,37 +0,0 @@
-require_relative "../transformer"
-
-module Metacrunch
-  class Transformer
-    class Step
-
-      def initialize(transformer)
-        @transformer = transformer
-      end
-
-      def perform
-        raise NotImplementedError, "You must implement .perform() in your rule sub-class"
-      end
-
-      def transformer
-        @transformer
-      end
-
-      def source
-        transformer.source
-      end
-
-      def target
-        transformer.target
-      end
-
-      def options
-        transformer.options
-      end
-
-      def helper
-        transformer.helper
-      end
-
-    end
-  end
-end

data/lib/metacrunch/transformer.rb

@@ -1,38 +0,0 @@
-module Metacrunch
-  class Transformer
-    require_relative "./transformer/step"
-    require_relative "./transformer/helper"
-
-    attr_accessor :source, :target, :options
-    attr_reader   :step
-
-
-    def initialize(source:nil, target:nil, options: {})
-      @source  = source
-      @target  = target
-      @options = options
-    end
-
-    def transform(step_class = nil, &block)
-      if block_given?
-        @step = Step.new(self)
-        @step.instance_eval(&block)
-      else
-        raise ArgumentError, "You need to provide a STEP or a block" if step_class.nil?
-        clazz = step_class.is_a?(Class) ? step_class : step_class.to_s.constantize
-        @step = clazz.new(self)
-        @step.perform
-      end
-    end
-
-    def helper
-      @helper ||= Helper.new(self)
-    end
-
-    def register_helper(helper_module)
-      raise ArgumentError, "Must be a module" unless helper_module.is_a?(Module)
-      helper.class.send(:include, helper_module) # TODO: Benchmark this
-    end
-
-  end
-end