unparser 0.4.7 → 0.6.7

data/lib/unparser/anima.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Original code before vendoring and reduction from: https://github.com/mbj/anima.
+  class Anima < Module
+    include Adamantium, Equalizer.new(:attributes)
+
+    # Return names
+    #
+    # @return [AttributeSet]
+    attr_reader :attributes
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # rubocop:disable Lint/MissingSuper
+    def initialize(*names)
+      @attributes = names.uniq.map(&Attribute.public_method(:new)).freeze
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    # Return new anima with attributes added
+    #
+    # @return [Anima]
+    #
+    # @example
+    #   anima = Anima.new(:foo)
+    #   anima.add(:bar) # equals Anima.new(:foo, :bar)
+    #
+    def add(*names)
+      new(attribute_names + names)
+    end
+
+    # Return new anima with attributes removed
+    #
+    # @return [Anima]
+    #
+    # @example
+    #   anima = Anima.new(:foo, :bar)
+    #   anima.remove(:bar) # equals Anima.new(:foo)
+    #
+    def remove(*names)
+      new(attribute_names - names)
+    end
+
+    # Return attributes hash for instance
+    #
+    # @param [Object] object
+    #
+    # @return [Hash]
+    def attributes_hash(object)
+      attributes.each_with_object({}) do |attribute, attributes_hash|
+        attributes_hash[attribute.name] = attribute.get(object)
+      end
+    end
+
+    # Return attribute names
+    #
+    # @return [Enumerable<Symbol>]
+    def attribute_names
+      attributes.map(&:name)
+    end
+    memoize :attribute_names
+
+    # Initialize instance
+    #
+    # @param [Object] object
+    #
+    # @param [Hash] attribute_hash
+    #
+    # @return [self]
+    def initialize_instance(object, attribute_hash)
+      assert_known_attributes(object.class, attribute_hash)
+      attributes.each do |attribute|
+        attribute.load(object, attribute_hash)
+      end
+      self
+    end
+
+    # Static instance methods for anima infected classes
+    module InstanceMethods
+      # Initialize an anima infected object
+      #
+      # @param [#to_h] attributes
+      #   a hash that matches anima defined attributes
+      #
+      # @return [undefined]
+      #
+      # rubocop:disable Lint/MissingSuper
+      def initialize(attributes)
+        self.class.anima.initialize_instance(self, attributes)
+      end
+      # rubocop:enable Lint/MissingSuper
+
+      # Return a hash representation of an anima infected object
+      #
+      # @example
+      #   anima.to_h # => { :foo => : bar }
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        self.class.anima.attributes_hash(self)
+      end
+
+      # Return updated instance
+      #
+      # @example
+      #   klass = Class.new do
+      #     include Anima.new(:foo, :bar)
+      #   end
+      #
+      #   foo = klass.new(:foo => 1, :bar => 2)
+      #   updated = foo.with(:foo => 3)
+      #   updated.foo # => 3
+      #   updated.bar # => 2
+      #
+      # @param [Hash] attributes
+      #
+      # @return [Anima]
+      #
+      # @api public
+      def with(attributes)
+        self.class.new(to_h.update(attributes))
+      end
+    end # InstanceMethods
+
+    private
+
+    # Infect the instance with anima
+    #
+    # @param [Class, Module] scope
+    #
+    # @return [undefined]
+    def included(descendant)
+      descendant.instance_exec(self, attribute_names) do |anima, names|
+        # Define anima method
+        define_singleton_method(:anima) { anima }
+
+        # Define instance methods
+        include InstanceMethods
+
+        # Define attribute readers
+        attr_reader(*names)
+
+        # Define equalizer
+        include Equalizer.new(*names)
+      end
+    end
+
+    # Fail unless keys in +attribute_hash+ matches #attribute_names
+    #
+    # @param [Class] klass
+    #   the class being initialized
+    #
+    # @param [Hash] attribute_hash
+    #   the attributes to initialize +object+ with
+    #
+    # @return [undefined]
+    #
+    # @raise [Error]
+    def assert_known_attributes(klass, attribute_hash)
+      keys = attribute_hash.keys
+
+      unknown = keys - attribute_names
+      missing = attribute_names - keys
+
+      unless unknown.empty? && missing.empty?
+        fail Error.new(klass, missing, unknown)
+      end
+    end
+
+    # Return new instance
+    #
+    # @param [Enumerable<Symbol>] attributes
+    #
+    # @return [Anima]
+    def new(attributes)
+      self.class.new(*attributes)
+    end
+  end # Anima
+end # Unparser

data/lib/unparser/ast/local_variable_scope.rb

@@ -61,35 +61,22 @@ module Unparser
       #
       # @api private
       #
-      def first_assignment_in_body_and_used_in_condition?(body, condition)
-        condition_reads = AST.local_variable_reads(condition)
+      def first_assignment_in?(left, right)
+        condition_reads = AST.local_variable_reads(right)
 
-        candidates = AST.local_variable_assignments(body).select do |node|
-          name = node.children.first
-          condition_reads.include?(name)
+        candidates = AST.local_variable_assignments(left).select do |node|
+          condition_reads.include?(node.children.first)
         end
 
-        candidates.any? do |node|
-          first_assignment?(node)
-        end
+        candidates.any?(&public_method(:first_assignment?))
       end
 
     private
 
-      # Match node
-      #
-      # @param [Parser::AST::Node] needle
-      #   if block given
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
       def match(needle)
         @items.each do |node, current, before|
           return yield(current, before) if node.equal?(needle)
         end
-        false
       end
 
     end # LocalVariableScope
@@ -137,25 +124,10 @@ module Unparser
 
     private
 
-      # Return current set of local variables
-      #
-      # @return [Set<Symbol>]
-      #
-      # @api private
-      #
       def current
         @stack.last
       end
 
-      # Visit node and record local variable state
-      #
-      # @param [Parser::AST::Node] node
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      # ignore :reek:LongYieldList
       def visit(node, &block)
         before = current.dup
         enter(node)
@@ -166,75 +138,33 @@ module Unparser
         leave(node)
       end
 
-      # Record local variable state
-      #
-      # @param [Parser::AST::Node] node
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def enter(node)
         case node.type
         when *RESET_NODES
           push_reset
-        when *ASSIGN_NODES
+        when ASSIGN_NODES
           define(node.children.first)
         when *INHERIT_NODES
           push_inherit
         end
       end
 
-      # Pop from local variable state
-      #
-      # @param [Parser::AST::Node] node
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def leave(node)
         pop if CLOSE_NODES.include?(node.type)
       end
 
-      # Define a local variable on current stack
-      #
-      # @param [Symbol] name
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def define(name)
         current << name
       end
 
-      # Push reset scope on stack
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def push_reset
         @stack << Set.new
       end
 
-      # Push inherited lvar scope on stack
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def push_inherit
         @stack << current.dup
       end
 
-      # Pop lvar scope from stack
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def pop
         @stack.pop
       end

data/lib/unparser/ast.rb

@@ -2,9 +2,7 @@
 
 module Unparser
   # Namespace for AST processing tools
-  # :reek:TooManyConstants
   module AST
-
     FIRST_CHILD = ->(node) { node.children.first }.freeze
     TAUTOLOGY   = ->(_node) { true }.freeze
 
@@ -80,7 +78,7 @@ module Unparser
 
     # AST enumerator
     class Enumerator
-      include Adamantium::Flat, Concord.new(:node, :controller), Enumerable
+      include Adamantium, Concord.new(:node, :controller), Enumerable
 
       # Return new instance
       #

data/lib/unparser/buffer.rb

@@ -3,8 +3,6 @@
 module Unparser
 
   # Buffer used to emit into
-  #
-  # ignore :reek:TooManyMethods
   class Buffer
 
     NL = "\n".freeze
@@ -46,7 +44,6 @@ module Unparser
     #
     def append_without_prefix(string)
       write(string)
-      self
     end
 
     # Increase indent
@@ -79,7 +76,13 @@ module Unparser
     #
     def nl
       write(NL)
-      self
+    end
+
+    def root_indent
+      before = @indent
+      @indent = 0
+      yield
+      @indent = before
     end
 
     # Test for a fresh line
@@ -102,39 +105,25 @@ module Unparser
       @content.dup.freeze
     end
 
-    # Capture the content written to the buffer within the block
+    # Write raw fragment to buffer
     #
-    # @return [String]
+    # Does not do indentation logic.
     #
-    # @api private
+    # @param [String] fragment
     #
-    def capture_content
-      size_before = @content.size
-      yield
-      @content[size_before..-1]
+    # @return [self]
+    def write(fragment)
+      @content << fragment
+      self
     end
 
   private
 
     INDENT_SPACE = '  '.freeze
 
-    # Write prefix
-    #
-    # @return [String]
-    #
-    # @api private
-    #
     def prefix
       write(INDENT_SPACE * @indent)
     end
 
-    # Write to content buffer
-    #
-    # @param [String] fragment
-    #
-    def write(fragment)
-      @content << fragment
-    end
-
   end # Buffer
 end # Unparser

data/lib/unparser/cli.rb

@@ -1,29 +1,61 @@
 # frozen_string_literal: true
 
-require 'unparser'
-require 'optparse'
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-
-require 'unparser/cli/source'
-require 'unparser/cli/differ'
-require 'unparser/cli/color'
-
 module Unparser
   # Unparser CLI implementation
-  #
-  # :reek:InstanceVariableAssumption
-  # :reek:TooManyInstanceVariables
   class CLI
 
     EXIT_SUCCESS = 0
     EXIT_FAILURE = 1
 
+    class Target
+      include AbstractType
+
+      # Path target
+      class Path < self
+        include Concord.new(:path)
+
+        # Validation for this target
+        #
+        # @return [Validation]
+        def validation
+          Validation.from_path(path)
+        end
+
+        # Literal for this target
+        #
+        # @return [Validation]
+        def literal_validation
+          Validation::Literal.from_path(path)
+        end
+      end
+
+      # String target
+      class String
+        include Concord.new(:string)
+
+        # Validation for this target
+        #
+        # @return [Validation]
+        def validation
+          Validation.from_string(string)
+        end
+
+        # Literal for this target
+        #
+        # @return [Validation]
+        def literal_validation
+          Validation::Literal.from_string(path)
+        end
+      end # String
+    end # Target
+
+    private_constant(*constants(false))
+
     # Run CLI
     #
     # @param [Array<String>] arguments
     #
-    # @return [Fixnum]
+    # @return [Integer]
     #   the exit status
     #
     # @api private
@@ -39,22 +71,22 @@ module Unparser
     # @return [undefined]
     #
     # @api private
-    #
-    # ignore :reek:TooManyStatements
     def initialize(arguments)
-      @sources = []
-      @ignore = Set.new
+      @ignore  = Set.new
+      @targets = []
 
-      @success   = true
-      @fail_fast = false
-      @verbose   = false
+      @fail_fast  = false
+      @start_with = nil
+      @success    = true
+      @validation = :validation
+      @verbose    = false
 
       opts = OptionParser.new do |builder|
         add_options(builder)
       end
 
       opts.parse!(arguments).each do |name|
-        @sources.concat(sources(name))
+        @targets.concat(targets(name))
       end
     end
 
@@ -66,38 +98,40 @@ module Unparser
     #
     # @api private
     #
-    # ignore :reek:TooManyStatements
+    # rubocop:disable Metrics/MethodLength
     def add_options(builder)
       builder.banner = 'usage: unparse [options] FILE [FILE]'
       builder.separator('')
       builder.on('-e', '--evaluate SOURCE') do |source|
-        @sources << Source::String.new(source)
+        @targets << Target::String.new(source)
       end
-      builder.on('--start-with FILE') do |file|
-        @start_with = sources(file).first
+      builder.on('--start-with FILE') do |path|
+        @start_with = targets(path).first
       end
       builder.on('-v', '--verbose') do
         @verbose = true
       end
+      builder.on('-l', '--literal') do
+        @validation = :literal_validation
+      end
       builder.on('--ignore FILE') do |file|
-        @ignore.merge(sources(file))
+        @ignore.merge(targets(file))
       end
       builder.on('--fail-fast') do
         @fail_fast = true
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
     # Return exit status
     #
-    # @return [Fixnum]
+    # @return [Integer]
     #
     # @api private
     #
     def exit_status
-      effective_sources.each do |source|
-        next if @ignore.include?(source)
-
-        process_source(source)
+      effective_targets.each do |target|
+        process_target(target)
         break if @fail_fast && !@success
       end
 
@@ -106,67 +140,41 @@ module Unparser
 
   private
 
-    # Process source
-    #
-    # @param [CLI::Source] source
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def process_source(source)
-      if source.success?
-        puts source.report if @verbose
-        puts "Success: #{source.identification}"
+    def process_target(target)
+      validation = target.public_send(@validation)
+      if validation.success?
+        puts validation.report if @verbose
+        puts "Success: #{validation.identification}"
       else
-        puts source.report
-        puts "Error: #{source.identification}"
+        puts validation.report
+        puts "Error: #{validation.identification}"
         @success = false
       end
     end
 
-    # Return effective sources
-    #
-    # @return [Enumerable<CLI::Source>]
-    #
-    # @api private
-    #
-    def effective_sources
+    def effective_targets
       if @start_with
         reject = true
-        @sources.reject do |source|
-          if reject && source.eql?(@start_with)
+        @targets.reject do |targets|
+          if reject && targets.eql?(@start_with)
             reject = false
           end
 
           reject
         end
       else
-        @sources
-      end
+        @targets
+      end.reject(&@ignore.method(:include?))
     end
 
-    # Return sources for file name
-    #
-    # @param [String] file_name
-    #
-    # @return [Enumerable<CLI::Source>]
-    #
-    # @api private
-    #
-    # ignore :reek:UtilityFunction
-    def sources(file_name)
-      files =
-        if File.directory?(file_name)
-          Dir.glob(File.join(file_name, '**/*.rb')).sort
-        elsif File.file?(file_name)
-          [file_name]
-        else
-          Dir.glob(file_name).sort
-        end
-
-      files.map(&Source::File.method(:new))
+    def targets(file_name)
+      if File.directory?(file_name)
+        Dir.glob(File.join(file_name, '**/*.rb')).sort
+      elsif File.file?(file_name)
+        [file_name]
+      else
+        Dir.glob(file_name).sort
+      end.map { |file| Target::Path.new(Pathname.new(file)) }
     end
-
   end # CLI
 end # Unparser

data/lib/unparser/{cli/color.rb → color.rb}

@@ -3,16 +3,13 @@
 module Unparser
   # Class to colorize strings
   class Color
-    include Adamantium::Flat, Concord.new(:code)
+    include Adamantium, Concord.new(:code)
 
     # Format text with color
     #
     # @param [String] text
     #
     # @return [String]
-    #
-    # @api private
-    #
     def format(text)
       "\e[#{code}m#{text}\e[0m"
     end
@@ -25,28 +22,21 @@ module Unparser
       #
       # @return [String]
       #   the argument string
-      #
-      # @api private
-      #
       def format(text)
         text
       end
 
     private
 
-      # Initialize null color
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
+      # Well rubocop you are static so you do not have a clue here ;)
+      # rubocop:disable Style/RedundantInitialize
       def initialize; end
+      # rubocop:enable Style/RedundantInitialize
 
     end.new
 
     RED   = Color.new(31)
     GREEN = Color.new(32)
-    BLUE  = Color.new(34)
 
   end # Color
 end # Unparser