each_with_flag 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5df8102224b53f67d378fd86feb93e935b473b1
+  data.tar.gz: 230851298d7a7399074e5c4c4e8931d467d7fb22
+SHA512:
+  metadata.gz: 963fbff974d019c580cc4a05a15a252a7b0ededf889b911e2ce6958e89c095b3b6f10203a4fa9eabaaf110afae403d15aa5878e1eede5a20b71e609e615bbb9e
+  data.tar.gz: 3ee903da722b1faec1f409eb1c2de56a444a3907eab83712941eed89471048ec03cf8263b8e3ea9f6d86f1b2f2e324a0e801a2e601a254bc7a1ab0971f3147ac

data/MANIFEST

@@ -0,0 +1,8 @@
+* CHANGES
+* README.md
+* MANIFEST
+* Rakefile
+* each_with_flag.gemspec
+* lib/enumerable/each_with_flag.rb
+* lib/each_with_flag.rb
+* test/test_each_with_flag.rb

data/README.md

@@ -0,0 +1,60 @@
+# Each with flags
+
+Each with flags gem provides Enumerable methods"each_with_flag" and "each_with_index_with_flag" that expands standard methods "each" and "each_with_index" adding to yield block flags of first, has previous, surrounded, has next and has last element.
+
+# Methods
+
+## each_with_flag
+
+Extend method each adding flags.
+
+### Usage
+```ruby
+enumerable_obj.each_with_flag(flags) do |item, flag1, flag2| do
+    # Your code here
+end
+```
+### Available flags
+
+- :first - is item first
+- :is_first - same as :first
+- :has_previous - is item has previous item in list
+- :has_prev - same as :has_previous
+- :surrounded - is item has previous and next item in list
+- :is_surrounded - same as :surrounded
+- :has_next - is item has next item in list
+- :last - is item last in list
+- :is_last - same as :last
+
+### Example
+```ruby
+['foo', 'bar', 'baz'].each_with_flag(:first, :surrounded, :last) do |item, is_first, is_surrounded, is_last| do
+    # is_first will be true only on first iteration
+    # is_surrounded will be true only on second iteration
+    # is_last will be true only on last iteration
+end
+```
+
+## each_with_index_with_flag
+The same as "each_with_flag" like "each" and "each_with_index"
+
+## Additional method
+Every flag has two additional metnods "each_with_{{flag_name}}" and "each_with_index_with_{{flag_name}}"
+
+### Example
+```ruby
+['foo', 'bar', 'baz'].each_with_first_flag do |item, is_first,| do
+    # is_first will be true only on first iteration
+end
+
+['foo', 'bar', 'baz'].each_with_index_with_first_flag do |item, index, is_first,| do
+    # is_first will be true only on first iteration
+end
+```
+
+## Version
+0.1.0
+
+License
+----
+MIT

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+
+CLEAN.include('*.gem', '*.rbc')
+
+namespace :gem do
+  desc 'Build the each-with-flag gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('each-with-flag.gemspec'))
+    if Gem::VERSION < '2.0'
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
+  end
+
+  desc 'Install the each_with_flag library as a gem'
+  task :install => [:create] do
+    file = Dir['*.gem'].first
+    sh "gem install -l #{file}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.warning = true
+  t.verbose = true
+end
+
+task :default => :test

data/each_with_flag.gemspec

@@ -0,0 +1,23 @@
+require File.expand_path('../lib/each_with_flag/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'each_with_flag'
+  s.version       = EachWithFlag::VERSION
+  s.date          = '2015-10-18'
+  s.summary       = 'Enhanced each methods (each with flags) for Enumerable objects'
+  s.authors       = ['Oleh Birjukov']
+  s.email         = 'ol.birjukov@gmail.com'
+  s.files         = Dir['**/*'].reject { |f| f.include?('git') }
+  s.homepage      = 'https://github.com/all-bear/rubygem.each_with_flag'
+  s.license       = 'MIT'
+  s.test_files    = s.files.grep(%r{^(test)/})
+  s.require_paths = ['lib']
+  s.description = <<-EOF
+     The each-with-flag library provides Enumerable methods
+     "each_with_flag" and "each_with_index_with_flag"
+     that expand standard methods "each" and "each_with_index"
+     adding to yield block flags of first, has previous, surrounded, has next and has last element.
+  EOF
+
+  s.add_development_dependency 'test-unit', '~> 3.0'
+end

data/lib/each_with_flag.rb

@@ -0,0 +1,6 @@
+require 'each_with_flag/version'
+require 'each_with_flag/enumerable/each_with_flag'
+
+module EachWithFlag
+
+end

data/lib/each_with_flag/enumerable/each_with_flag.rb

@@ -0,0 +1,80 @@
+module Enumerable
+  # The version of the each-with-flag library.
+  EACH_WITH_FLAG_VERSION = '0.1.0'
+
+  EACH_WITH_FLAG_FLAGS = {
+      :first        => [:first, :is_first],
+      :has_previous => [:has_previous, :has_prev],
+      :surrounded   => [:surrounded, :is_surrounded],
+      :has_next     => :has_next,
+      :last         => [:last, :is_last]
+  }
+
+  def each_with_flag(*params)
+    self.each_with_index do |data, index|
+      yield data, *flags(index, params)
+    end
+  end
+
+  def each_with_index_with_flag(*params)
+    self.each_with_index do |data, index|
+      yield data, index, *flags(index, params)
+    end
+  end
+
+  def self.all_user_flags
+    [EACH_WITH_FLAG_FLAGS.values].flatten
+  end
+
+  private_class_method :all_user_flags
+
+  all_user_flags.each do |flag|
+    define_method "each_with_#{flag}_flag" do |&b|
+      self.each_with_flag(flag) do |*params|
+        b.call *params
+      end
+    end
+
+    define_method "each_with_index_with_#{flag}_flag" do |&b|
+      self.each_with_index_with_flag(flag) do |*params|
+        b.call *params
+      end
+    end
+  end
+
+  private
+
+  def user_flags_for(name)
+    [EACH_WITH_FLAG_FLAGS[name]].flatten
+  end
+
+  def slice_hash(hash, keys)
+    keys.each_with_object({}) do |k, h|
+      h[k] = hash[k] if hash.has_key?(k)
+    end
+  end
+
+  def define_flag(user_flags, flag_name, value)
+    user_flags_for(flag_name).each_with_object(user_flags) do |user_flag, flags|
+      flags[user_flag] = value
+      flags
+    end
+  end
+
+  def last_index
+    self.size - 1
+  end
+
+  def flags(index, params)
+    flags = {}
+
+    define_flag(flags, :first, index == 0)
+    define_flag(flags, :has_previous, 0 < index)
+    define_flag(flags, :surrounded, 0 < index && index < last_index)
+    define_flag(flags, :has_next, index < last_index)
+    define_flag(flags, :last, index == last_index)
+    define_flag(flags, :first, index == 0)
+
+    slice_hash(flags, params).values
+  end
+end

data/lib/each_with_flag/version.rb

@@ -0,0 +1,3 @@
+module EachWithFlag
+  VERSION = "0.1.0"
+end

data/test/test_each_with_flag.rb

@@ -0,0 +1,228 @@
+########################################################################
+# test_each_with_flag.rb
+#
+# Test case for the enumerable-extra library. You should run this
+# test via the 'rake test' task.
+########################################################################
+require 'test-unit'
+require 'enumerable/each_with_flag'
+
+class Test_Enumerable_EachWithFlag < Test::Unit::TestCase
+  TEST_ITEM_SIZE = 3
+
+  def setup
+    @array = %w/foo bar baz/
+    @hash  = {:a => 'foo', :b => 'bar', :c => 'baz'}
+
+    @expected_flags = {
+        :first        => [true, false, false],
+        :has_previous => [false, true, true],
+        :surrounded   => [false, true, false],
+        :has_next     => [true, true, false],
+        :last         => [false, false, true]
+    }
+
+    @expected_flag_mask = (0..(TEST_ITEM_SIZE - 1)).each_with_object([]) do |index, mask|
+      mask[index] = @expected_flags.each_with_object([]) do |data, mask|
+        mask << data[1][index]
+      end
+    end
+
+    @flag_params = [:first, :has_previous, :surrounded, :has_next, :last]
+
+    @real_flag_masks = []
+    @yielded_flags   = []
+    @yielded_items   = []
+    @yielded_keys    = []
+    @yielded_indexes = []
+    @yield_counter   = 0
+  end
+
+  test 'version number is set properly' do
+    assert_equal('0.1.0', Enumerable::EACH_WITH_FLAG_VERSION)
+  end
+
+  def test_each_with_flag
+    check_respond_to :each_with_flag
+  end
+
+  def test_each_with_flag_for_hash
+    @hash.send(:each_with_flag, *@flag_params) do |data, is_first, has_previous, surrounded, has_next, is_last|
+      add_key data[0]
+      add_item data[1]
+      add_flag_mask [is_first, has_previous, surrounded, has_next, is_last]
+      increase_yield_counter
+    end
+
+    check_flag_result_data @hash
+  end
+
+  def test_each_with_flag_for_hash_reversed_params
+    @hash.send(:each_with_flag, *@flag_params.reverse) do |data, is_last, has_next, surrounded, has_previous, is_first|
+      add_key data[0]
+      add_item data[1]
+      add_flag_mask [is_first, has_previous, surrounded, has_next, is_last]
+      increase_yield_counter
+    end
+
+    check_flag_result_data @hash
+  end
+
+  def test_each_with_flag_for_array
+    @array.send(:each_with_flag, *@flag_params) do |item, is_first, has_previous, surrounded, has_next, is_last|
+      add_item item
+      add_flag_mask [is_first, has_previous, surrounded, has_next, is_last]
+      increase_yield_counter
+    end
+
+    check_flag_result_data @array
+  end
+
+  def test_each_with_flag_for_array_reversed_params
+    @array.send(:each_with_flag, *@flag_params.reverse) do |item, is_last, has_next, surrounded, has_previous, is_first|
+      add_item item
+      add_flag_mask [is_first, has_previous, surrounded, has_next, is_last]
+      increase_yield_counter
+    end
+
+    check_flag_result_data @array
+  end
+
+  def test_each_with_first_flag
+    check_respond_to :each_with_first_flag
+  end
+
+  test 'each with special flags' do
+    @flag_params.each { |flag| check_each_with_special flag }
+  end
+
+  test 'each with index with special flags' do
+    @flag_params.each { |flag| check_each_with_index_with_special flag }
+  end
+
+  def teardown
+    @array = nil
+    @hash  = nil
+
+    @real_flag_masks = nil
+    @yielded_flags   = nil
+    @yielded_items   = nil
+    @yielded_keys    = nil
+    @yield_counter   = nil
+    @yielded_indexes = nil
+  end
+
+  private
+  def restart
+    teardown
+    setup
+  end
+
+  def check_respond_to(method)
+    [@array, @hash].each do |item|
+      assert_respond_to(item, method)
+    end
+  end
+
+  def add_flag_mask(mask)
+    @real_flag_masks << mask
+  end
+
+  def increase_yield_counter
+    @yield_counter = @yield_counter + 1
+  end
+
+  def add_item(item)
+    @yielded_items << item
+  end
+
+  def add_key(key)
+    @yielded_keys << key
+  end
+
+  def add_index(index)
+    @yielded_indexes << index
+  end
+
+  def add_flag(flag)
+    @yielded_flags << flag
+  end
+
+  def check_general_result_data(subject, params)
+    assert_equal TEST_ITEM_SIZE, @yield_counter, 'Invalid count of block calls'
+
+    if subject.is_a? Hash
+      assert_equal @yielded_items, subject.values, 'Invalid items was passed to block'
+    elsif subject.is_a? Array
+      assert_equal @yielded_items, subject, 'Invalid items was passed to block'
+    end
+
+    assert_equal @yielded_keys, subject.keys, 'Invalid keys was passed to block' if subject.is_a? Hash
+
+    assert_equal @yielded_indexes, [0, 1, 2], 'Invalid indexes was passed to block' if params[:with_index]
+  end
+
+  def check_special_flag_result_data(subject, flag, params = {})
+    check_general_result_data(subject, params)
+
+    assert_equal @expected_flags[flag], @yielded_flags, 'Invalid flags'
+  end
+
+  def check_flag_result_data(subject, params = {})
+    check_general_result_data(subject, params)
+
+    assert_equal @expected_flag_mask, @real_flag_masks, 'Invalid flags'
+  end
+
+  def check_each_with_special(special)
+    method_name = "each_with_#{special}_flag"
+
+    @array.send(method_name) do |item, is_first|
+      add_item item
+      add_flag is_first
+      increase_yield_counter
+    end
+
+    check_special_flag_result_data @array, special
+
+    restart
+
+    @hash.send(method_name) do |data, is_first|
+      add_key data[0]
+      add_item data[1]
+      add_flag is_first
+      increase_yield_counter
+    end
+
+    check_special_flag_result_data @hash, special
+
+    restart
+  end
+
+  def check_each_with_index_with_special(special)
+    method_name = "each_with_index_with_#{special}_flag"
+
+    @array.send(method_name) do |item, index, is_first|
+      add_item item
+      add_index index
+      add_flag is_first
+      increase_yield_counter
+    end
+
+    check_special_flag_result_data @array, special, :with_index => true
+
+    restart
+
+    @hash.send(method_name) do |data, index, is_first|
+      add_key data[0]
+      add_item data[1]
+      add_index index
+      add_flag is_first
+      increase_yield_counter
+    end
+
+    check_special_flag_result_data @hash, special, :with_index => true
+
+    restart
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: each_with_flag
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Oleh Birjukov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2
+       The each-with-flag library provides Enumerable methods
+       "each_with_flag" and "each_with_index_with_flag"
+       that expand standard methods "each" and "each_with_index"
+       adding to yield block flags of first, has previous, surrounded, has next and has last element.
+email: ol.birjukov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGES
+- MANIFEST
+- README.md
+- Rakefile
+- each_with_flag.gemspec
+- lib/each_with_flag.rb
+- lib/each_with_flag/enumerable/each_with_flag.rb
+- lib/each_with_flag/version.rb
+- test/test_each_with_flag.rb
+homepage: https://github.com/all-bear/rubygem.each_with_flag
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Enhanced each methods (each with flags) for Enumerable objects
+test_files:
+- test/test_each_with_flag.rb