rails_zen 0.1.0

data/lib/rails_zen/given_model_gen.rb

@@ -0,0 +1,76 @@
+require 'rails_zen/chosen_attr'
+require 'rails_zen/write_to_files'
+require 'highline/import'
+
+module RailsZen
+  class GivenModelGen
+    attr_accessor :name, :raw_attributes, :simple_attributes
+
+    def initialize(name, raw_attrs)
+      @name = name
+      @raw_attributes = raw_attrs
+      @simple_attributes = []
+    end
+
+
+    def step_by_step
+      say "\nThese are your attributes"
+      say "---------------------------\n"
+
+      attrs.each_with_index { |attr, i| puts "#{i} #{attr}" }
+      say "\n\nChoose the one that don't require 'presence true' or 'validations' or uniqueness.\n Enter like this eg: 0,1. or just enter "
+      say "\n----------------------------------\n\n$.> "
+
+      @simple_attributes =  ask("Enter (comma sep list)  ", lambda { |str| str.split(/,\s*/) })
+
+      chosen_attrs.each do |attr_obj|
+        attr_obj.get_user_inputs
+        RailsZen::WriteToFiles.new(attr_obj, name).write
+      end
+
+      ask_for_has_many_relations
+    end
+
+    def chosen_attrs
+
+      attr_hash = attrs_with_types
+      final_attr_objs = []
+      i = -1
+      attr_hash.each do |attr, type|
+        i += 1
+        unless simple_attributes.include? "#{i}"
+          final_attr_objs << RailsZen::ChosenAttr.new(attr, type)
+        end
+      end
+      final_attr_objs
+    end
+
+
+    def ask_for_has_many_relations
+      say "\nDo you have any has_many relations? Enter the name if so, otherwise leave it. eg: posts,comments"
+
+      @has_many_relations =  ask("Enter (comma sep list)  ", lambda { |str| str.split(/,\s*/) })
+
+      @has_many_relations.each do |rel|
+
+        m = RailsZen::WriteToModel.new
+        m.model_name = @name
+        m.adding_to_file!("  has_many :#{rel}\n")
+
+        s = RailsZen::WriteToSpec.new
+        s.model_name = @name
+        s.adding_to_file!("it { is_expected.to have_many(:#{rel}) }")
+      end
+
+    end
+    def attrs
+      raw_attributes.scan(/\w+(?=:)/)
+    end
+    private
+    def attrs_with_types
+      raw_attributes.scan(/(\w+):(\w+)/).to_h
+    end
+
+
+  end
+end

data/lib/rails_zen/model_action.rb

@@ -0,0 +1,106 @@
+require 'rails_zen/write_to_files/write_to_model'
+require 'rails_zen/write_to_files/write_to_spec'
+require 'highline/import'
+
+module RailsZen
+  class ModelAction
+    attr_writer :is_class_action
+
+    def initialize(name, is_class_action, model)
+      @name = name
+      @model = model
+      @is_class_action = is_class_action
+      @arg_names = []
+      @args = []
+    end
+
+    def write!
+      get_necessary_info
+
+      m = RailsZen::WriteToModel.new
+      m.model_name = @model
+      m.adding_to_file!(action_string)
+
+      s = RailsZen::WriteToSpec.new
+      s.model_name = @model
+
+      unless File.foreach("spec/models/#{@model}_spec.rb").grep(factory_girl_match).any? #check for factory
+        s.adding_to_file!(factory_method)
+      end
+      s.adding_to_file!(action_spec_string)
+    end
+
+    private
+
+    def factory_girl_match
+      Regexp.new("FactoryGirl.create(:#{@model})")
+    end
+
+    def get_necessary_info
+      say "What does your method do? (Please don't use 'it' or 'should' in your definition)\n"
+      @functionality = ask("Eg: returns sum of 2 numbers\n")
+
+      say "\n\n------------ARGUMENTS-----------------\n"
+
+      say "\nWhat name would you give your arguments for the #{@name} method? eg: num1,num2\n"
+
+      @arg_names = ask("Enter (comma sep) list", lambda { |str| str.split(/,\s*/) })
+
+      if @arg_names.any?
+        say "\nGive example arguments inputs\n"
+        @args =  ask("Enter (comma sep list). Eg: 1,2 ", lambda { |str| str.split(/,\s*/) })
+      end
+
+
+      @expected = ask("Enter the expected output for the previously entered arguments. eg: 3")
+    end
+
+    def action_string
+      %{
+      def #{method_with_args}
+      end
+      }
+    end
+
+    def action_spec_string
+      if @is_class_action
+      %{
+      it { is_expected.to respond_to :#{@name}}
+
+      describe ".#{@name}" do
+        it "#{@functionality}" do
+          expect(#{@model.capitalize}.#{@name}(#{sample_arguments})).to eq \"#{@expected}\"
+        end
+      end
+
+      }
+      else
+        %{
+        describe "##{@name}" do
+          it "#{@functionality}" do
+            expect(#{@model}.#{@name}(#{sample_arguments})).to eq \"#{@expected}\"
+          end
+        end
+
+        }
+      end
+    end
+    def method_with_args
+      if @is_class_action
+        "self.#{@name}(#{arguments})"
+      else
+        "#{@name}(#{arguments})"
+      end
+    end
+
+    def sample_arguments
+      @args.join(", ")
+    end
+    def arguments
+      @arg_names.join(", ")
+    end
+    def factory_method
+      "let(:#{@model}) { FactoryGirl.create(:#{@model}) }"
+    end
+  end
+end

data/lib/rails_zen/version.rb

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

data/lib/rails_zen/write_to_files.rb

@@ -0,0 +1,31 @@
+require 'rails_zen/write_to_files/write_to_spec'
+require 'rails_zen/write_to_files/write_to_model'
+require 'rails_zen/write_to_files/write_to_migration'
+
+class RailsZen::WriteToFiles
+  attr_reader :attr, :model_name
+
+  def initialize(attr, model_name)
+    @attr = attr
+    @model_name = model_name
+  end
+
+  def build_file_writers(type)
+    # When including thor, could not use initialize hence building it
+    Object.const_get("RailsZen::#{type}").new.tap do |w|
+      w.name                  = attr.name
+      w.attr_type             = attr.type
+      w.scope_attr            = attr.scope_attr
+      w.validator             = attr.validator
+      w.type_based_validators = attr.type_based_validators
+      w.model_name            = model_name
+    end
+  end
+
+  def write
+    ["WriteToSpec", "WriteToMigration", "WriteToModel"].each do |type|
+      build_file_writers(type).write!
+    end
+  end
+end
+

data/lib/rails_zen/write_to_files/model_level_validation.rb

@@ -0,0 +1,12 @@
+module RailsZen::ModelLeveLValidation
+
+  def validate_belongs_to
+    ""
+  end
+  def validate_numericality
+     ", numericality: true"
+  end
+  def validate_integer
+    ", numericality: { only_integer: true }"
+  end
+end

data/lib/rails_zen/write_to_files/model_level_validation_spec.rb

@@ -0,0 +1,14 @@
+module RailsZen::ModelLeveLValidationSpec
+
+  def validate_belongs_to
+    "it { is_expected.to belong_to(:#{name}) }"
+  end
+  def validate_numericality
+    "it { is_expected.to validates_numericality_of(:#{name}) }"
+  end
+  def validate_integer
+    "it { is_expected.to validates_numericality_of(:#{name}).only_integer }"
+  end
+end
+
+

data/lib/rails_zen/write_to_files/write_to_migration.rb

@@ -0,0 +1,37 @@
+require "rails_zen/write_to_files/write_to_model"
+require 'active_support/core_ext/string'
+
+class RailsZen::WriteToMigration < RailsZen::WriteToModel
+
+  def write!
+    if @validator
+      line = send(@validator)
+      append_to_line(line)
+    end
+    if scope_attr.any?
+      inject_into_file file_name, "t.index #{scope_attr.to_s}\n", before: "t.timestamps"
+    end
+  end
+  def append_to_line(line)
+    gsub_file file_name, /t.#{attr_type}.+#{name}.*$/ do |match|
+      match = line
+    end
+  end
+
+  def file_name
+    Dir.glob("db/migrate/*create_#{@model_name.pluralize}.rb")[0]
+    # need to use pluralize here
+  end
+
+  private
+  def validates_presence_of
+    "t.#{attr_type} :#{name}, required: true, null: false"
+  end
+  def validates_uniqueness_of
+    "t.#{attr_type} :#{name}, required: true, null: false, index: true"
+  end
+  def validates_uniqueness_scoped_to
+    "t.#{attr_type} :#{name}, required: true, null: false, index: true"
+  end
+end
+

data/lib/rails_zen/write_to_files/write_to_model.rb

@@ -0,0 +1,57 @@
+require 'thor'
+require "rails_zen/write_to_files/model_level_validation"
+
+module RailsZen
+  class WriteToModel
+
+
+    attr_accessor :name, :scope_attr, :validator, :type_based_validators, :model_name, :attr_type, :file_name
+    include RailsZen::ModelLeveLValidation
+    include Thor::Base
+    include Thor::Actions
+
+
+    def write!
+
+      if @validator
+        output = send(@validator)
+        if type_num?
+          type_output = send(@type_based_validators)
+          adding_to_file!("  #{output + type_output}\n" )
+        else
+          adding_to_file!("  #{output}\n")
+        end
+      end
+    end
+
+    def adding_to_file!(line)
+      inject_into_class(file_name, model_name.capitalize, line)
+    end
+
+    def file_name
+      "app/models/#{model_name}.rb"
+    end
+    private
+
+    def type_num?
+      @attr_type == "integer" || @attr_type == "decimal"
+    end
+    def validates_presence_of
+      "validates :#{name}, presence: true"
+    end
+    def validates_uniqueness_of
+      "validates :#{name}, presence: true, uniqueness: true"
+    end
+    def validates_uniqueness_scoped_to
+      "validates_uniqueness_of :#{scope_attr[0]}, scope: #{resolve_scope}"
+    end
+
+    def resolve_scope
+      if scope_attr.length == 2
+        ":#{scope_attr[1]}"
+      else
+        scope_attr[1..-1].to_s
+      end
+    end
+  end
+end

data/lib/rails_zen/write_to_files/write_to_spec.rb

@@ -0,0 +1,45 @@
+require "rails_zen/write_to_files/model_level_validation_spec"
+require "rails_zen/write_to_files/write_to_model"
+
+class RailsZen::WriteToSpec < RailsZen::WriteToModel
+
+  include RailsZen::ModelLeveLValidationSpec
+
+  def write!
+    if @validator
+      unless File.foreach("spec/models/#{@model_name}_spec.rb").grep(factory_girl_match).any?
+        adding_to_file!(factory_method)
+      end
+      adding_to_file!(send(@validator))
+
+    end
+
+    adding_to_file!(send(@type_based_validator)) if @type_based_validator
+  end
+  def adding_to_file!(output)
+    inject_into_file(file_name, "  #{output}\n", after: "RSpec.describe #{@model_name.capitalize}, type: :model do\n" )
+  end
+
+  private
+  def factory_girl_match
+    Regexp.new("FactoryGirl.create(:#{@model_name})")
+  end
+  def factory_method
+    "let(:#{@model_name}) { FactoryGirl.create(:#{@model_name}) }"
+  end
+
+  def file_name
+    "spec/models/#{@model_name}_spec.rb"
+  end
+
+  def validates_presence_of
+    "it { #{@model_name}; is_expected.to validate_presence_of(:#{name})}"
+  end
+  def validates_uniqueness_of
+    "it { #{@model_name}; is_expected.to validate_uniqueness_of(:#{name})}"
+  end
+  def validates_uniqueness_scoped_to
+    "it { #{@model_name}; is_expected.to validate_uniqueness_of(:#{scope_attr[0]}).scoped_to(#{resolve_scope})}"
+  end
+
+end

data/lib/railtie.rb

@@ -0,0 +1,8 @@
+module MyGem
+  class Railtie < Rails::Railtie
+    initializer "Include your code in the controller" do
+      ActiveSupport.on_load(:action_controller) do
+        include MyGem
+      end
+    end
+end

data/rails_zen.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_zen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_zen"
+  spec.version       = RailsZen::VERSION
+  spec.authors       = ["Vysakh Sreenivasan"]
+  spec.email         = ["diplomatv@gmail.com"]
+  spec.summary       = %q{Interactive rails generator generating files (models, migration) and related specs.}
+  spec.description   = %q{Automate the writing of validations, relations in files and specs. Create boilerplate validation in models, specs, migrations. This specs are generated based on rspec, shoulda-matchers and factorygirl }
+  spec.homepage      = "http://github.com/vysakh0/rails_zen"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor', "~> 0.19"
+  spec.add_dependency 'highline', "~> 1.4"
+  spec.add_dependency 'activesupport', "~> 4.2"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "aruba", "~> 0.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+end

data/spec/chosen_attr_spec.rb

@@ -0,0 +1,92 @@
+require 'rails_zen/chosen_attr'
+
+RSpec.describe RailsZen::ChosenAttr do
+
+
+  subject {
+    RailsZen::ChosenAttr.new("name", "string")
+  }
+
+  #after do
+    #$stdin = STDIN
+  #end
+
+  it { is_expected.to respond_to :get_user_inputs}
+
+
+  describe "#get_presence_req" do
+
+    context "when 'y' for presence" do
+
+      context "when 0 for uniqueness" do
+        it "sets validator to validates_presence_of" do
+          set_stream(StringIO.new("y\n0\n"))
+          subject.get_user_inputs
+          expect(subject.validator).to eq "validates_presence_of"
+        end
+      end
+      context "when '1' for uniqueness" do
+        it "sets validator to validates_uniqueness_of" do
+          set_stream(StringIO.new("y\nr\n1\n"))
+          subject.get_user_inputs
+          expect(subject.validator).to eq "validates_uniqueness_of"
+        end
+      end
+      context "when '2' for uniqueness" do
+        it "sets validator to validates_uniqueness_scoped_to" do
+          set_stream(StringIO.new("y\n 2\n order_id\n"))
+          subject.get_user_inputs
+          expect(subject.validator).to eq "validates_uniqueness_scoped_to"
+        end
+      end
+    end
+    context "when n for presence" do
+
+      fit "sets validator to validates_presence_of" do
+        set_stream(StringIO.new("n\n"))
+        subject.get_user_inputs
+        expect(subject.validator).to be nil
+      end
+
+    end
+
+    describe "#get_type_based_validations" do
+      context "when type is integer" do
+
+        before do
+          @chosen = RailsZen::ChosenAttr.new("phone", "integer")
+        end
+        context "when just the numericality is chosen" do
+          fit "sets type_based_validators to validate_numericality" do
+            set_stream(StringIO.new("1\n"))
+            @chosen.get_type_based_validations
+            expect(@chosen.type_based_validators).to eq "validate_numericality"
+          end
+        end
+        context "when numericality with integer is chosen" do
+          it "sets type_based_validators to validate_integer" do
+            set_stream(StringIO.new("2\n"))
+            @chosen.get_type_based_validations
+            expect(@chosen.type_based_validators).to eq "validate_integer"
+          end
+        end
+      end
+      context "when type is a relation" do
+        before do
+          @chosen = RailsZen::ChosenAttr.new("user", "belongs_to")
+        end
+        it "sets type_based_validators to validate_belongs_to" do
+          @chosen.get_type_based_validations
+          expect(@chosen.type_based_validators).to eq "validate_belongs_to"
+        end
+      end
+    end
+  end
+end
+
+def set_stream(input)
+  #inp = $terminal.instance_variable_get(:@input)
+  #inp.flush
+  $terminal.instance_variable_set(:@input, input)
+  # highline set input, $stdin setting is not working. i.e $stdin = input
+end