Haskell, 27 bytes

scanl((a:b)_->b++[a])=<<id

Try it online!

APL (Dyalog Unicode), 6 bytes^SBCS

⍳∘≢⌽¨⊂

Try it online!

⍳ the indices

∘ of

≢ the tally

⌽¨ each rotate (to the left)

⊂ the entire string

JavaScript (ES6), 37 32 bytes

Returns an array of strings.

s=>[...s].map(c=>s=s.slice(1)+c)

Try it online!

Python 2, 38 bytes

s=input()

for c in s:s=s[1:]+c;print s

Try it online!

Japt, 5 3 bytes

Takes input as a character array, outputs an array of character arrays

£=é

Try it here

        :Implicit input of character array U

£       :Map

  é     :  Rotate right

=       :  Reassign to U for next iteration

MATL, 6 5 bytes

tf&+)

1 byte saved thanks to @luis!

Try it at MATL Online!

Explanation:

    # Implicitly grab input string

t   # Duplicate the input

f   # Create an array [1, ..., N] where N is the number of characters in the input

&+  # Add the transpose of this array to itself to create a 2D array of indices

    #

    #   +   1  2  3  4

    #       ----------

    #   1 | 2  3  4  5

    #   2 | 3  4  5  6

    #   3 | 4  5  6  7

    #   4 | 5  6  7  8

    #

)   # Use this 2D array to index into the original string using periodic indexing

    # Implicitly display the resulting character array

05AB1E, 3 bytes

ā._

Try it online!

Attache, 13 bytes

Rotate#{1:#_}

Try it online!

Explanation

Rotate#{1:#_}

      #          fork(f, g) = ${ f[x, g[x]] }; this forks:

Rotate               rotate's the input by

       {1:#_}        each number from 1 to the length of the input

Alternatives

15 bytes: {_&Rotate!1:#_}

16 bytes: {Rotate[_,1:#_]}

16 bytes: Rotate@Rotations

16 bytes: Rotate#(1&`:@`#)

17 bytes: Rotate#{1+Iota@_}

18 bytes: Rotate#(1&`+@Iota)

19 bytes: Rotate#(Succ=>Iota)

R, 58 bytes

function(s,`[`=substring)paste0(s[n<-nchar(s):1],s[1,n-1])

Try it online!

brainfuck, 59 bytes

,[>,]<[>>[>]+[<]<[<]>-[[>]>[>]<+[<]<[<]>-]>[.>]>[.>]<[<].<]

Try it online!

Outputs each string separated by null bytes.

Explanation:

,[>,]    # Get input

<[       # Start loop over input

  >>[>]       # Go to end of the string

  +           # Set it to one to mark it

  [<]<[<]>    # Move to the beginning of input

  -[[>]>[>]<+[<]<[<]>-]   # Transfer the first character to the end

  >[.>]>[.>]  # Print the rotated string

  <[<].       # Print a nul byte

<]       # Repeat loop while input

Wolfram Language (Mathematica), 35 26 bytes

Partition[#,Tr[1^#],1,-1]&

Try it online!

Takes a list of characters as input.

Partition (but not its variant StringPartitionused below) has an optional fourth argument for treating its input as cyclic (and for specifying how exactly to do so), which makes this solution simpler than the string one - in addition to not having any 15-character built-in functions.

Wolfram Language (Mathematica), 44 bytes

Rest@StringPartition[#<>#,StringLength@#,1]&

Try it online!

The same, but takes a string as input.

Turns "john" into "johnjohn", then takes all the length-StringLength["john"] substrings of this string with offset 1, producing {"john","ohnj","hnjo","njoh","john"}, then drops the first of these with Rest.

Charcoal, 10 bytes

⮌Ｅθ⭆θ§θ⁻μκ

Try it online! Link is to verbose version of code. Explanation:

  θ         Input string

 Ｅ         Map over characters

    θ       Input string

   ⭆        Map over characters and join

      θ     Input string

     §      Circularly indexed by

       ⁻    Difference between

        μ   Inner index

         κ  Outer index

⮌           Reversed

            Implicitly print each string on its own line

To rotate in the opposite direction, replace Minus with Plus.

J, 7 bytes

#|."{]

Try it online!

Explanation:

  |."{    - rotate ( "{ is short for "0 1 - rank 0 1 ) 

      ]   - the input

#        - lenght of the successive prefixes of the input 

Red, 49 43 bytes

func[s][forall s[print move head s tail s]]

Try it online!

Python 2, 54 48 bytes

lambda i:[i[x:]+i[:x]for x in range(1,len(i)+1)]

Try it online!

Well beaten by xnor but posted as an alternative approach anyway.

Perl 6, 32 bytes

{m:ex/^(.*)(.+)$/».&{[R~] @$_}}

Try it online!

m:ex/^(.*)(.+)$/ exhaustively matches the given regex, splitting the input string at every possible place, except that the second substring must have at least one character--that prevents the input string from showing up twice in the output. Then each of the resulting Match objects' capture groups are reduced () to a single string with R~, the reversed string concatenation operator.

C# (Visual C# Interactive Compiler), 34 bytes

x=>x.Select(c=>x=x.Substring(1)+c)

Try it online!

V, 8 bytes

ýñx$pÙñd

Try it online!

Hexdump:

00000000: fdf1 7824 70d9 f164                      ..x$p..d

Tcl, 80 91 bytes

proc P s {time {puts [set s [string ra $s 1 e][string in $s 0]]} [string le $s]}

Try it online!

C (32-bit), 58 51 bytes

i;f(s){for(i=0;i++<printf("%s%.*sn",s+i,i,s)-2;);}

Try it online!

Degolf

i;           // "Global" i.

f(s){   // s is pointer to string, which conveniently fits in a 32 bit integer.

    for(i=0; // Initialize i.

        // Post-increment i, compare to return value of printf,

        // which just happens to be the number of chars printed, i.e.

        // the length of string s plus 1. Because the printf() is

        // evaluated before the comparison, we need to deduct 2 instead

        // of 1 from the return value.

        i++ < printf("%s%.*sn",s+i,i,s);)-2;

        // The printf prints two strings: first until the terminating ,

        // the second until a  or until i chars have been printed.

}

Ruby, 39 bytes

->s{a=s.chars.to_a;a.map{a.rotate!*''}}

Try it online!

Pyth, 11 bytes

VSlQ+>QN<QN

Try it online!

Pretty much just a port of my Python answer

Explanation

==================================================

assign('Q',eval_input())

for N in num_to_range(Psorted(Plen(Q))):

 imp_print(plus(gt(Q,N),lt(Q,N)))

==================================================



V                    # for N in 

 S                   # 1-indexed range

  lQ                 # length of evaluated input

    +                # concatanate

     >QN             # all characters after index N in Q (Q[N:])

        <QN          # and all characters before index N in Q (Q[:N])

Tcl, 78 bytes

proc R t {time {puts [set t [regsub -all (.?)(.*) $t {21}]]} [string le $t]}

Try it online!

Pushy, 4 bytes

L:{"

Try it online!

L:     Length of the string times do:

  {       Cyclically shift left once

   "      Print

Perl 6, 20 bytes

{.rotate(all 1..$_)}

Try it online!

Anonymous code block that has input/output as a list of characters. The output is a Junction object that contains all the rotated arrays. I'm not sure how legal this is, since extracting values from a Junction is not normal.

Explanation:

{                  }   # Anonymous codeblock

 .rotate(         )    # Rotate the input list

         all 1..$_     # By all of the range 1 to length of the input array

                          # all creates a junction of values

                          # And it runs the function on each value

The all can be replaced by any of any, one, [&], [|], [^].

If the Junction isn't allowed, here's an alternate solution for 22 bytes:

{.&{.rotate(++$)xx$_}}

Try it online!

There's probably a better way to reset the anonymous variable ++$ than by wrapping the code in another code block...

JavaScript, 48 43 bytes

-5 bytes courtesy of @Bubbler

s=>[...s].map(_=>([a,...b]=s,s=b.join``+a))

Try it online!

Powershell, 44 bytes

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

Test script:

$f = {



($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}



}



@(

    ,('john', 'ohnj', 'hnjo', 'njoh', 'john')

    ,('heehee', 'eeheeh', 'eheehe', 'heehee', 'eeheeh', 'eheehe', 'heehee')

) | % {

    $s,$expected = $_

    $result = &$f $s

    "$result"-eq"$expected"

    $result

}

output:

True

ohnj

hnjo

njoh

john

True

eeheeh

eheehe

heehee

eeheeh

eheehe

heehee

Pepe, 64 bytes

REEeRREeeeREEEEEREErEEEEErRREEEEEEEREEEeeReReeeReeErRrEEEEEEERee

Try it online! Uses newlines for separation.

Java (JDK), 85 bytes

s->{for(int i=s.length();i-->0;)System.out.println(s.substring(i)+s.substring(0,i));}

Try it online!